aboutsummaryrefslogtreecommitdiff
path: root/pd
diff options
context:
space:
mode:
Diffstat (limited to 'pd')
-rw-r--r--pd/extra/bonk~/README.txt30
-rw-r--r--pd/extra/bonk~/bonk~.c1083
-rw-r--r--pd/extra/bonk~/makefile97
-rw-r--r--pd/extra/bonk~/templates.txt4
-rw-r--r--pd/extra/expr~/LICENSE.txt341
-rw-r--r--pd/extra/expr~/README67
-rw-r--r--pd/extra/expr~/fts_to_pd.h41
-rw-r--r--pd/extra/expr~/help-expr.pd231
-rw-r--r--pd/extra/expr~/makefile160
-rw-r--r--pd/extra/expr~/vexp.c1948
-rw-r--r--pd/extra/expr~/vexp.h233
-rw-r--r--pd/extra/expr~/vexp_fun.c828
-rw-r--r--pd/extra/expr~/vexp_if.c931
-rw-r--r--pd/extra/fiddle~/README.txt33
-rw-r--r--pd/extra/fiddle~/fiddle~.c1818
-rw-r--r--pd/extra/fiddle~/makefile97
-rw-r--r--pd/extra/loop~/loop~.c164
-rw-r--r--pd/extra/loop~/makefile97
-rw-r--r--pd/extra/loop~/test-loop~.pd56
-rw-r--r--pd/extra/lrshift~/lrshift~.c74
-rw-r--r--pd/extra/lrshift~/makefile97
-rw-r--r--pd/extra/paf~/README.txt12
-rw-r--r--pd/extra/paf~/makefile97
-rw-r--r--pd/extra/paf~/paf~.c927
24 files changed, 9466 insertions, 0 deletions
diff --git a/pd/extra/bonk~/README.txt b/pd/extra/bonk~/README.txt
new file mode 100644
index 00000000..6b0017cd
--- /dev/null
+++ b/pd/extra/bonk~/README.txt
@@ -0,0 +1,30 @@
+Bonk is copyright (C) 1997 Regents of the University of California.
+Permission is granted to use this software for any purpose, commercial
+or noncommercial, as long as this notice is included with all copies.
+
+UC MAKES NO WARRANTY, EXPRESS OR IMPLIED, IN CONNECTION WITH THIS SOFTWARE!
+
+----------------------------------------------------------------------------
+
+This is the README file for the "bonk" percussion detector. This software
+is available from http://man104nfs.ucsd.edu/~mpuckett in versions for
+IRIX 5.x and for NT on Intel boxes.
+
+Bonk will soon be available separately for Max/MSP on Macintoshes.
+
+TO INSTALL FOR IRIX 5.x: download from the Web page, which will give you a
+file named "bonk-x.xx.tar.Z" (where x.xx is the version number). Unpack this
+by typing "zcat bonk-x.xx.tar.Z | tar xf -" which will give you a directory
+named "bonk" containing the source, the object code, and the "help patch."
+
+TO INSTALL FOR NT: download from the Web page, which will give you a file
+named "bonk-x.xx.zip" (where x.xx is the version number). Unpack this by
+typing "unzip bonk-x.xx.zip" to a terminal window which will give you a
+directory named "bonk". The source, the object code, and the "help patch"
+will be there.
+
+Pd currently has no search path facility; the object file (bonk.pd_irix5 or
+bonk.dll) should be copied to the directories containing whatever patches you
+want to use it with.
+
+-Miller Puckette (msp@ucsd.edu)
diff --git a/pd/extra/bonk~/bonk~.c b/pd/extra/bonk~/bonk~.c
new file mode 100644
index 00000000..6b8cfa76
--- /dev/null
+++ b/pd/extra/bonk~/bonk~.c
@@ -0,0 +1,1083 @@
+/* Copyright 1997-1999 Miller Puckette (msp@ucsd.edu) and Ted Apel
+(tapel@ucsd.edu). Permission is granted to use this software for any
+noncommercial purpose. For commercial licensing please contact the UCSD
+Technology Transfer Office.
+
+THE AUTHORS AND THEIR EMPLOYERS MAKE NO WARRANTY, EXPRESS OR IMPLIED,
+IN CONNECTION WITH THIS SOFTWARE!
+*/
+
+#include <math.h>
+#include <stdio.h>
+
+#ifdef NT
+#pragma warning (disable: 4305 4244)
+#endif
+
+#ifdef MSP
+
+#include "ext.h"
+#include "z_dsp.h"
+#include "math.h"
+//#include "stdio.h"
+#include "ext_support.h"
+//#include "ext_strings.h"
+#include "ext_proto.h"
+
+typedef double t_floatarg; // from m_pd.h
+#define flog log
+#define fexp exp
+#define fsqrt sqrt
+#define t_resizebytes(a, b, c) t_resizebytes((char *)(a), (b), (c))
+
+#define flog log
+#define fexp exp
+#define fsqrt sqrt
+
+#define FILE_DIALOG 1 /* use dialogs to get file name */
+#define FILE_NAMED 2 /* symbol specifies file name */
+
+#define DUMTAB1SIZE 256
+#define DUMTAB2SIZE 1024
+
+static float rsqrt_exptab[DUMTAB1SIZE], rsqrt_mantissatab[DUMTAB2SIZE];
+
+void *bonk_class;
+#define getbytes t_getbytes
+#define freebytes t_freebytes
+#endif /* MSP */
+
+#ifdef PD
+#include "m_pd.h"
+static t_class *bonk_class;
+#endif
+
+/* ------------------------ bonk~ ----------------------------- */
+
+#define NPOINTS 256
+#define MAXCHANNELS 8
+#define DEFPERIOD 128
+#define DEFHITHRESH 60
+#define DEFLOTHRESH 50
+#define DEFMASKTIME 4
+#define DEFMASKDECAY 0.7
+#define DEFDEBOUNCEDECAY 0
+#define DEFMINVEL 7
+
+
+
+typedef struct _filterkernel
+{
+ int k_npoints;
+ float k_freq;
+ float k_normalize;
+ float *k_stuff;
+} t_filterkernel;
+
+#if 0 /* this is the design for 1.0: */
+static t_filterkernel bonk_filterkernels[] =
+ {{256, 2, .01562}, {256, 4, .01562}, {256, 6, .01562}, {180, 6, .02222},
+ {128, 6, .01803}, {90, 6, .02222}, {64, 6, .02362}, {46, 6, .02773},
+ {32, 6, .03227}, {22, 6, .03932}, {16, 6, .04489}};
+#endif
+
+ /* here's the 1.1 rev: */
+static t_filterkernel bonk_filterkernels[] =
+ {{256, 1, .01562, 0}, {256, 3, .01562, 0}, {256, 5, .01562, 0},
+ {212, 6, .01886, 0}, {150, 6, .01885, 0}, {106, 6, .02179, 0},
+ {76, 6, .0236, 0}, {54, 6, .02634, 0}, {38, 6, .03047, 0},
+ {26, 6, .03667, 0}, {18, 6, .04458, 0}};
+
+#define NFILTERS ((int)(sizeof(bonk_filterkernels)/ \
+ sizeof(bonk_filterkernels[0])))
+
+static float bonk_hanningwindow[NPOINTS];
+
+typedef struct _hist
+{
+ float h_power;
+ float h_mask;
+ float h_before;
+ int h_countup;
+} t_hist;
+
+typedef struct template
+{
+ float t_amp[NFILTERS];
+} t_template;
+
+typedef struct _insig
+{
+ t_hist g_hist[NFILTERS]; /* history for each filter */
+#ifdef PD
+ t_outlet *g_outlet; /* outlet for raw data */
+#endif
+#ifdef MSP
+ void *g_outlet; /* outlet for raw data */
+#endif
+ float *g_inbuf; /* buffered input samples */
+ t_float *g_invec; /* new input samples */
+} t_insig;
+
+typedef struct _bonk
+{
+#ifdef PD
+ t_object x_obj;
+ t_outlet *x_cookedout;
+ t_clock *x_clock;
+#endif /* PD */
+#ifdef MSP
+ t_pxobject x_obj;
+ void *x_cookedout; // t_outlet *x_cookedout;
+ void *x_clock; // t_clock *x_clock;
+ short x_vol; // to store the volume reference number.
+#endif /* MSP */
+
+ t_hist x_hist[NFILTERS];
+ t_template *x_template;
+ t_insig *x_insig;
+ int x_ninsig;
+ int x_ntemplate;
+ int x_infill;
+ int x_countdown;
+ int x_period;
+ int x_willattack;
+ int x_debug;
+ float x_hithresh;
+ float x_lothresh;
+ int x_masktime;
+ float x_maskdecay;
+ int x_learn;
+ double x_learndebounce; /* debounce time for "learn" mode */
+ int x_learncount; /* countup for "learn" mode */
+ float x_debouncedecay;
+ float x_minvel; /* minimum velocity we output */
+ float x_debouncevel;
+} t_bonk;
+
+#ifdef MSP
+static void *bonk_new(int period, int bonk2);
+void bonk_tick(t_bonk *x);
+void bonk_doit(t_bonk *x);
+static t_int *bonk_perform(t_int *w);
+void bonk_dsp(t_bonk *x, t_signal **sp);
+void bonk_assist(t_bonk *x, void *b, long m, long a, char *s);
+void bonk_thresh(t_bonk *x, t_floatarg f1, t_floatarg f2);
+void bonk_mask(t_bonk *x, t_floatarg f1, t_floatarg f2);
+void bonk_debounce(t_bonk *x, t_floatarg f1);
+static void bonk_print(t_bonk *x, t_floatarg f);
+static void bonk_learn(t_bonk *x, t_floatarg f);
+void bonk_bang(t_bonk *x);
+void bonk_setupkernels(void);
+void bonk_free(t_bonk *x);
+void bonk_setup(void);
+void main();
+float qrsqrt(float f);
+static void bonk_write(t_bonk *x, t_symbol *s);
+static void bonk_read(t_bonk *x, t_symbol *s);
+
+double clock_getsystime();
+double clock_gettimesince(double prevsystime);
+static char *strcpy(char *s1, const char *s2);
+static int ilog2(int n);
+#endif
+
+static void bonk_tick(t_bonk *x);
+
+static void bonk_donew(t_bonk *x, int period, int nsig)
+{
+ int i, j;
+ t_hist *h;
+ float *fp;
+ t_insig *g;
+
+ for (j = 0, g = x->x_insig; j < nsig; j++, g++)
+ {
+ for (i = 0, h = g->g_hist; i--; h++)
+ h->h_power = h->h_mask = h->h_before = 0, h->h_countup = 0;
+ /* we ought to check for failure to allocate memory here */
+ g->g_inbuf = (float *)getbytes(NPOINTS * sizeof(float));
+ for (i = NPOINTS, fp = g->g_inbuf; i--; fp++) *fp = 0;
+ }
+ x->x_ninsig = nsig;
+ x->x_template = (t_template *)getbytes(0);
+ x->x_ntemplate = 0;
+ x->x_infill = 0;
+ x->x_countdown = 0;
+ if (!period) period = NPOINTS/2;
+ x->x_period = 1 << ilog2(period);
+ x->x_willattack = 0;
+ x->x_debug = 0;
+ x->x_hithresh = DEFHITHRESH;
+ x->x_lothresh = DEFLOTHRESH;
+ x->x_masktime = DEFMASKTIME;
+ x->x_maskdecay = DEFMASKDECAY;
+ x->x_learn = 0;
+ x->x_learndebounce = clock_getsystime();
+ x->x_learncount = 0;
+ x->x_debouncedecay = DEFDEBOUNCEDECAY;
+ x->x_minvel = DEFMINVEL;
+ x->x_debouncevel = 0;
+}
+
+
+static void bonk_print(t_bonk *x, t_floatarg f);
+
+static void bonk_dotick(t_bonk *x, int hit)
+{
+ t_atom at[NFILTERS], *ap, at2[3];
+ int i, j, k, n;
+ t_hist *h;
+ float powerout[NFILTERS*MAXCHANNELS], *pp, vel = 0, temperature = 0;
+ float *fp;
+ t_template *tp;
+ int nfit, ninsig = x->x_ninsig, ntemplate = x->x_ntemplate;
+ t_insig *gp;
+ int totalbins = NFILTERS * ninsig;
+
+ x->x_willattack = 0;
+
+ for (i = ninsig, pp = powerout, gp = x->x_insig; i--; gp++)
+ {
+ for (j = 0, h = gp->g_hist; j < NFILTERS; j++, h++, pp++)
+ {
+ float power = (hit ? h->h_mask - h->h_before : h->h_power);
+ float intensity = *pp =
+ (power > 0 ? 100. * qrsqrt(qrsqrt(power)) : 0);
+ vel += intensity;
+ temperature += intensity * (float)j;
+ }
+ }
+ if (vel > 0) temperature /= vel;
+ else temperature = 0;
+ vel *= 0.5 / ninsig; /* fudge factor */
+ if (hit)
+ {
+ /* if hit nonzero it's a clock callback. if in "learn" mode update the
+ template list; in any event match the hit to known templates. */
+
+ if (vel < x->x_debouncevel)
+ {
+ if (x->x_debug)
+ post("bounce cancelled: vel %f debounce %f",
+ vel, x->x_debouncevel);
+ return;
+ }
+ if (vel < x->x_minvel)
+ {
+ if (x->x_debug)
+ post("low velocity cancelled: vel %f, minvel %f",
+ vel, x->x_minvel);
+ return;
+ }
+ x->x_debouncevel = vel;
+ if (x->x_learn)
+ {
+ double lasttime = x->x_learndebounce;
+ double msec = clock_gettimesince(lasttime);
+ if ((!ntemplate) || (msec > 200))
+ {
+ int countup = x->x_learncount;
+ /* normalize to 100 */
+ float norm;
+ for (i = NFILTERS * ninsig, norm = 0, pp = powerout; i--; pp++)
+ norm += *pp * *pp;
+ if (norm < 1.0e-15) norm = 1.0e-15;
+ norm = 100.f * qrsqrt(norm);
+ /* check if this is the first strike for a new template */
+ if (!countup)
+ {
+ int oldn = ntemplate;
+ x->x_ntemplate = ntemplate = oldn + ninsig;
+ x->x_template = (t_template *)t_resizebytes(x->x_template,
+ oldn * sizeof(x->x_template[0]),
+ ntemplate * sizeof(x->x_template[0]));
+ for (i = ninsig, pp = powerout; i--; oldn++)
+ for (j = NFILTERS, fp = x->x_template[oldn].t_amp; j--;
+ pp++, fp++)
+ *fp = *pp * norm;
+ }
+ else
+ {
+ int oldn = ntemplate - ninsig;
+ if (oldn < 0) post("bonk_tick bug");
+ for (i = ninsig, pp = powerout; i--; oldn++)
+ {
+ for (j = NFILTERS, fp = x->x_template[oldn].t_amp; j--;
+ pp++, fp++)
+ *fp = (countup * *fp + *pp * norm)
+ /(countup + 1.0f);
+ }
+ }
+ countup++;
+ if (countup == x->x_learn) countup = 0;
+ x->x_learncount = countup;
+ }
+ else return;
+ }
+ x->x_learndebounce = clock_getsystime();
+ if (ntemplate)
+ {
+ float bestfit = -1e30;
+ int templatecount;
+ nfit = -1;
+ for (i = 0, templatecount = 0, tp = x->x_template;
+ templatecount < ntemplate; i++)
+ {
+ float dotprod = 0;
+ for (k = 0, pp = powerout;
+ k < ninsig && templatecount < ntemplate;
+ k++, tp++, templatecount++)
+ {
+ for (j = NFILTERS, fp = tp->t_amp;
+ j--; fp++, pp++)
+ {
+ if (*fp < 0 || *pp < 0) post("bonk_tick bug 2");
+ dotprod += *fp * *pp;
+ }
+ }
+ if (dotprod > bestfit)
+ {
+ bestfit = dotprod;
+ nfit = i;
+ }
+ }
+ if (nfit < 0) post("bonk_tick bug");
+ }
+ else nfit = 0;
+ }
+ else nfit = -1; /* hit is zero; this is the "bang" method. */
+
+ if (x->x_debug)
+ post("bonk out: number %d, vel %f, temperature %f",
+ nfit, vel, temperature);
+ SETFLOAT(at2, nfit);
+ SETFLOAT(at2+1, vel);
+ SETFLOAT(at2+2, temperature);
+ outlet_list(x->x_cookedout, 0, 3, at2);
+
+ for (n = 0, gp = x->x_insig + (ninsig-1),
+ pp = powerout + NFILTERS * (ninsig-1);
+ n < ninsig; n++, gp--, pp -= NFILTERS)
+ {
+ float *pp2;
+ for (i = 0, ap = at, pp2 = pp; i < NFILTERS;
+ i++, ap++, pp2++)
+ {
+ ap->a_type = A_FLOAT;
+ ap->a_w.w_float = *pp2;
+ }
+ outlet_list(gp->g_outlet, 0, NFILTERS, at);
+ }
+}
+
+static void bonk_tick(t_bonk *x)
+{
+ bonk_dotick(x, 1);
+}
+
+static void bonk_doit(t_bonk *x)
+{
+ int i, j, n;
+ t_filterkernel *k;
+ t_hist *h;
+ float growth = 0, *fp1, *fp2, *fp3, *fp4;
+ float windowbuf[NPOINTS];
+ static int poodle;
+ int ninsig = x->x_ninsig;
+ t_insig *gp;
+
+ for (n = 0, gp = x->x_insig; n < ninsig; n++, gp++)
+ {
+ for (i = NPOINTS, fp1 = gp->g_inbuf, fp2 = bonk_hanningwindow,
+ fp3 = windowbuf; i--; fp1++, fp2++, fp3++)
+ *fp3 = *fp1 * *fp2;
+
+ for (i = 0, k = bonk_filterkernels, h = gp->g_hist;
+ i < NFILTERS; i++, k++, h++)
+ {
+ float power = 0, maskpow = h->h_mask;
+ int countup = h->h_countup;
+ int npoints = k->k_npoints;
+ /* special case: the fourth filter is centered */
+ float *inbuf = gp->g_inbuf +
+ (i == 3 ? ((NPOINTS - npoints) / 2) : 0);
+
+ /* run the filter repeatedly, sliding it forward by half its
+ length, stopping when it runs past the end of the buffer */
+ for (fp1 = inbuf, fp2 = fp1 + NPOINTS - k->k_npoints;
+ fp1 <= fp2; fp1 += npoints/2)
+ {
+ float rsum = 0, isum = 0;
+ for (fp3 = fp1, fp4 = k->k_stuff, j = npoints; j--;)
+ {
+ float g = *fp3++;
+ rsum += g * *fp4++;
+ isum += g * *fp4++;
+ }
+ power += rsum * rsum + isum * isum;
+ }
+
+ if (!x->x_willattack) h->h_before = maskpow;
+
+ if (power > maskpow)
+ growth += power/(maskpow + 1.0e-15) - 1.f;
+ if (!x->x_willattack && countup >= x->x_masktime)
+ maskpow *= x->x_maskdecay;
+
+ if (power > maskpow)
+ {
+ maskpow = power;
+ countup = 0;
+ }
+ countup++;
+ h->h_countup = countup;
+ h->h_mask = maskpow;
+ h->h_power = power;
+ }
+ }
+ if (x->x_willattack > 4)
+ {
+ /* if it takes more than 4 analyses for the energy to stop growing,
+ forget it; we would rather miss the note than report it late. */
+ if (x->x_debug) post("soft attack cancelled");
+ x->x_willattack = 0;
+ }
+ else if (x->x_willattack)
+ {
+ if (growth < x->x_lothresh)
+ clock_delay(x->x_clock, 0);
+ else x->x_willattack++;
+ }
+ else if (growth > x->x_hithresh)
+ {
+ if (x->x_debug) post("attack; growth = %f", growth);
+ x->x_willattack = 1;
+ for (n = 0, gp = x->x_insig; n < ninsig; n++, gp++)
+ for (i = NFILTERS, h = gp->g_hist; i--; h++)
+ h->h_mask = h->h_power, h->h_countup = 0;
+ }
+
+ x->x_debouncevel *= x->x_debouncedecay;
+
+ /* shift the input buffer and update counters */
+ if (x->x_period > NPOINTS) x->x_countdown = x->x_period - NPOINTS;
+ else x->x_countdown = 0;
+ if (x->x_period < NPOINTS)
+ {
+ int overlap = NPOINTS - x->x_period;
+
+ for (n = 0, gp = x->x_insig; n < ninsig; n++, gp++)
+ for (i = overlap, fp1 = gp->g_inbuf, fp2 = fp1 + x->x_period; i--;)
+ *fp1++ = *fp2++;
+ x->x_infill = overlap;
+ }
+ else x->x_infill = 0;
+ poodle = 1;
+}
+
+static t_int *bonk_perform(t_int *w)
+{
+ t_bonk *x = (t_bonk *)(w[1]);
+ int n = (int)(w[2]);
+ int onset = (int)(w[3]);
+ if (x->x_countdown > 0) x->x_countdown -= n;
+ else
+ {
+ int i, j, infill = x->x_infill, ninsig = x->x_ninsig;
+ t_insig *gp;
+ for (i = 0, gp = x->x_insig; i < ninsig; i++, gp++)
+ {
+ float *fp = gp->g_inbuf + infill;
+ t_float *in1 = gp->g_invec + onset;
+ for (j = 0; j < n; j++)
+ *fp++ = *in1++;
+ }
+ infill += n;
+ x->x_infill = infill;
+ if (infill == NPOINTS) bonk_doit(x);
+ }
+ return (w+4);
+}
+
+static void bonk_dsp(t_bonk *x, t_signal **sp)
+{
+ int i, n = sp[0]->s_n, vsize = x->x_period, ninsig = x->x_ninsig;
+ t_insig *gp;
+ if (vsize > n) vsize = n;
+
+ for (i = 0, gp = x->x_insig; i < ninsig; i++, gp++)
+ gp->g_invec = (*(sp++))->s_vec;
+
+ for (i = 0; i < n; i += vsize)
+ dsp_add(bonk_perform, 3, x, vsize, i);
+}
+
+static void bonk_thresh(t_bonk *x, t_floatarg f1, t_floatarg f2)
+{
+ if (f1 > f2)
+ post("bonk: warning: low threshold greater than hi threshold");
+ x->x_lothresh = f1;
+ x->x_hithresh = f2;
+}
+
+static void bonk_mask(t_bonk *x, t_floatarg f1, t_floatarg f2)
+{
+ int ticks = f1;
+ if (ticks < 0) ticks = 0;
+ if (f2 < 0) f2 = 0;
+ else if (f2 > 1) f2 = 1;
+ x->x_masktime = ticks;
+ x->x_maskdecay = f2;
+}
+
+static void bonk_debounce(t_bonk *x, t_floatarg f1)
+{
+ if (f1 < 0) f1 = 0;
+ else if (f1 > 1) f1 = 1;
+ x->x_debouncedecay = f1;
+}
+
+static void bonk_minvel(t_bonk *x, t_floatarg f)
+{
+ if (f < 0) f = 0;
+ x->x_minvel = f;
+}
+
+static void bonk_print(t_bonk *x, t_floatarg f)
+{
+ int i;
+ post("thresh %f %f", x->x_lothresh, x->x_hithresh);
+ post("mask %d %f", x->x_masktime, x->x_maskdecay);
+ post("debounce %f", x->x_debouncedecay);
+ post("minvel %f", x->x_minvel);
+ if (x->x_ntemplate)
+ {
+ post("templates:");
+ for (i = 0; i < x->x_ntemplate; i++)
+ post("%2d \
+%5.2f %5.2f %5.2f %5.2f %5.2f %5.2f %5.2f %5.2f %5.2f %5.2f %5.2f", i,
+ x->x_template[i].t_amp[0],
+ x->x_template[i].t_amp[1],
+ x->x_template[i].t_amp[2],
+ x->x_template[i].t_amp[3],
+ x->x_template[i].t_amp[4],
+ x->x_template[i].t_amp[5],
+ x->x_template[i].t_amp[6],
+ x->x_template[i].t_amp[7],
+ x->x_template[i].t_amp[8],
+ x->x_template[i].t_amp[9],
+ x->x_template[i].t_amp[10]);
+ }
+ else post("no templates");
+ if (x->x_learn) post("learn mode");
+ if (f != 0)
+ {
+ int j, ninsig = x->x_ninsig;
+ t_insig *gp;
+ for (j = 0, gp = x->x_insig; j < ninsig; j++, gp++)
+ {
+ t_hist *h;
+ if (ninsig > 1) post("input %d:", j+1);
+ for (i = NFILTERS, h = gp->g_hist; i--; h++)
+ post("pow %f mask %f before %f count %d",
+ h->h_power, h->h_mask, h->h_before, h->h_countup);
+ }
+ }
+ if (x->x_debug) post("debug mode");
+}
+
+static void bonk_debug(t_bonk *x, t_floatarg f)
+{
+ x->x_debug = (f != 0);
+}
+
+static void bonk_learn(t_bonk *x, t_floatarg f)
+{
+ int n = f;
+ if (n < 0) n = 0;
+ if (n)
+ {
+ x->x_template = (t_template *)t_resizebytes(x->x_template,
+ x->x_ntemplate * sizeof(x->x_template[0]), 0);
+ x->x_ntemplate = 0;
+ }
+ x->x_learn = n;
+ x->x_learncount = 0;
+}
+
+static void bonk_forget(t_bonk *x)
+{
+ int ntemplate = x->x_ntemplate, newn = ntemplate - x->x_ninsig;
+ if (newn < 0) newn = 0;
+ x->x_template = (t_template *)t_resizebytes(x->x_template,
+ x->x_ntemplate * sizeof(x->x_template[0]),
+ newn * sizeof(x->x_template[0]));
+ x->x_ntemplate = newn;
+ x->x_learncount = 0;
+}
+
+#if 0
+static void bonk_bang(t_bonk *x)
+{
+ t_atom at[NFILTERS];
+ int i, j, ninsig = x->x_ninsig;
+ t_insig *gp;
+
+ SETFLOAT(at2, nfit);
+ SETFLOAT(at2+1, vel);
+ SETFLOAT(at2+2, temperature);
+ outlet_list(x->x_cookedout, 0L, 3, at2);
+ for (i = 0, gp = x->x_insig + (ninsig-1); i < ninsig; i++, gp--)
+ {
+ for (j = 0; j < NFILTERS; j++)
+ {
+ at[j].a_type = A_FLOAT;
+ at[j].a_w.w_float = 100 * qrsqrt(qrsqrt(gp->g_hist[j].h_power));
+ }
+ outlet_list(gp->g_outlet, 0L, NFILTERS, at);
+ }
+}
+#endif
+
+static void bonk_bang(t_bonk *x)
+{
+ bonk_dotick(x, 0);
+}
+
+static void bonk_setupkernels(void)
+{
+ int i, j;
+ float *fp;
+ for (i = 0; i < NFILTERS; i++)
+ {
+ int npoints = bonk_filterkernels[i].k_npoints;
+ float freq = bonk_filterkernels[i].k_freq;
+ float normalize = bonk_filterkernels[i].k_normalize;
+ float phaseinc = (2.f * 3.14159f) / npoints;
+ bonk_filterkernels[i].k_stuff =
+ (float *)getbytes(2 * sizeof(float) * npoints);
+ for (fp = bonk_filterkernels[i].k_stuff, j = npoints; j--;)
+ {
+ float phase = j * phaseinc;
+ float window = normalize * (0.5f - 0.5f * cos(phase));
+ *fp++ = window * cos(freq * phase);
+ *fp++ = window * sin(freq * phase);
+ }
+ }
+ for (i = 0; i < NPOINTS; i++)
+ bonk_hanningwindow[i] = (0.5f - 0.5f * cos(i * (2*3.14159)/NPOINTS));
+}
+
+#ifdef PD
+static void bonk_read(t_bonk *x, t_symbol *s)
+{
+ FILE *fd = fopen(s->s_name, "r");
+ float vec[NFILTERS];
+ int i, ntemplate = 0, remaining;
+ float *fp, *fp2;
+ if (!fd)
+ {
+ post("%s: open failed", s->s_name);
+ return;
+ }
+ x->x_template = (t_template *)t_resizebytes(x->x_template,
+ x->x_ntemplate * sizeof(t_template), 0);
+ while (1)
+ {
+ for (i = NFILTERS, fp = vec; i--; fp++)
+ if (fscanf(fd, "%f", fp) < 1) goto nomore;
+ x->x_template = (t_template *)t_resizebytes(x->x_template,
+ ntemplate * sizeof(t_template),
+ (ntemplate + 1) * sizeof(t_template));
+ for (i = NFILTERS, fp = vec,
+ fp2 = x->x_template[ntemplate].t_amp; i--;)
+ *fp2++ = *fp++;
+ ntemplate++;
+ }
+nomore:
+ if (remaining = (ntemplate % x->x_ninsig))
+ {
+ post("bonk_read: %d templates not a multiple of %d; dropping extras");
+ x->x_template = (t_template *)t_resizebytes(x->x_template,
+ ntemplate * sizeof(t_template),
+ (ntemplate - remaining) * sizeof(t_template));
+ ntemplate = ntemplate - remaining;
+ }
+ post("bonk: read %d templates\n", ntemplate);
+ x->x_ntemplate = ntemplate;
+ fclose(fd);
+}
+#endif /* PD */
+
+#ifdef MSP
+static void bonk_read(t_bonk *x, t_symbol *s) // MSP
+{
+ SFTypeList types;
+ short vol = 0;
+ OSType type;
+ char name[256];
+ char **buf;
+ int eaten;
+ long size = 100;
+ int i, ntemplate = 0;
+ float vec[NFILTERS];
+ float *fp, *fp2;
+ if (s->s_name[0]) // if it is named
+ {
+ vol = defvolume();
+ strcpy (name, s->s_name);
+
+ if (readtohandle (name, vol, &buf, &size) != 0)
+
+ {
+ post("bonk~: problem with reading file.");
+ return;
+
+ }
+ else
+ {
+ post("bonk~: template read successfully.");
+ //post("bonk~: size of file is %d", size);
+ }
+ for (eaten = 0; ;)
+ {
+ for (i = NFILTERS, fp = vec; i--; fp++)
+ {
+ while (eaten < size && (
+ (*buf)[eaten] == ' ' ||
+ (*buf)[eaten] == '\t' ||
+ (*buf)[eaten] == '\n' ||
+ (*buf)[eaten] == ';' ||
+ (*buf)[eaten] == '\r'))
+ eaten++;
+ if (eaten >= size) goto nomore;
+ if (sscanf(&(*buf)[eaten], "%f", fp) < 1) goto nomore;
+
+ while (eaten < size && !(
+ (*buf)[eaten] == ' ' ||
+ (*buf)[eaten] == '\t' ||
+ (*buf)[eaten] == '\n' ||
+ (*buf)[eaten] == ';' ||
+ (*buf)[eaten] == '\r'))
+ eaten++;
+ }
+ x->x_template = (t_template *)t_resizebytes(x->x_template,
+
+ ntemplate * sizeof(t_template),
+ (ntemplate + 1) * sizeof(t_template));
+
+ for (i = NFILTERS, fp = vec,
+ fp2 = x->x_template[ntemplate].t_amp; i--;)
+ *fp2++ = *fp++;
+ ntemplate++;
+ post("bonk~: fp = %f", fp);
+ }
+ }
+ else
+ {
+ name[0] = 0;
+ types[0]='TEXT';
+ types[1]='maxb';
+
+ open_promptset("Select template for reading.");
+
+ if (open_dialog(name, &vol, &type, types, 2))
+ {
+ post("bonk~: open canceled");
+ return;
+ }
+ x->x_template = (t_template *)t_resizebytes(x->x_template,
+
+ x->x_ntemplate * sizeof(t_template), 0);
+
+ // post("bonk~: the file name is %s", name);
+
+ if (readtohandle (name, vol, &buf, &size) != 0)
+
+ {
+ post("bonk~: problem with reading file.");
+ return;
+
+ }
+ else
+ {
+ post("bonk~: template read successfully.");
+ // post("bonk~: size of file is %d", size);
+ }
+ for (eaten = 0; ;)
+ {
+ for (i = NFILTERS, fp = vec; i--; fp++)
+ {
+ while (eaten < size && (
+ (*buf)[eaten] == ' ' ||
+ (*buf)[eaten] == '\t' ||
+ (*buf)[eaten] == '\n' ||
+ (*buf)[eaten] == ';' ||
+ (*buf)[eaten] == '\r'))
+ eaten++;
+ if (eaten >= size) goto nomore;
+ if (sscanf(&(*buf)[eaten], "%f", fp) < 1) goto nomore;
+
+ while (eaten < size && !(
+ (*buf)[eaten] == ' ' ||
+ (*buf)[eaten] == '\t' ||
+ (*buf)[eaten] == '\n' ||
+ (*buf)[eaten] == ';' ||
+ (*buf)[eaten] == '\r'))
+ eaten++;
+ }
+ x->x_template = (t_template *)t_resizebytes(x->x_template,
+
+ ntemplate * sizeof(t_template),
+ (ntemplate + 1) * sizeof(t_template));
+
+ for (i = NFILTERS, fp = vec,
+ fp2 = x->x_template[ntemplate].t_amp; i--;)
+ *fp2++ = *fp++;
+ ntemplate++;
+ }
+ nomore:
+ post("bonk~: read %d templates", ntemplate);
+
+ x->x_ntemplate = ntemplate;
+ } // end of else
+}
+#endif /* MSP */
+
+#ifdef PD
+static void bonk_write(t_bonk *x, t_symbol *s)
+{
+ FILE *fd = fopen(s->s_name, "w");
+ int i, ntemplate = x->x_ntemplate;
+ t_template *tp = x->x_template;
+ float *fp;
+ if (!fd)
+ {
+ post("%s: couldn't create", s->s_name);
+ return;
+ }
+ for (; ntemplate--; tp++)
+ {
+ for (i = NFILTERS, fp = tp->t_amp; i--; fp++)
+ fprintf(fd, "%6.2f ", *fp);
+ fprintf(fd, "\n");
+ }
+ post("bonk: wrote %d templates\n", x->x_ntemplate);
+ fclose(fd);
+}
+#endif /* PD */
+
+#ifdef MSP
+static void bonk_write(t_bonk *x, t_symbol *s) // MSP
+{
+
+ char fn[236];
+ short vol;
+ short bin = 0; // 0 = text
+ void* b;
+ int i, ntemplate = x->x_ntemplate;
+ t_template *tp = x->x_template;
+ if (s->s_name[0]) // if it is named
+ {
+ strcpy (fn, s->s_name);
+ vol = defvolume();
+ b = binbuf_new();
+ for (; ntemplate--; tp++)
+ {
+ int i;
+ Atom at[11];
+ for (i = 0; i < 11; i++)
+ at[i].a_type = A_FLOAT, at[i].a_w.w_float = tp->t_amp[i];
+ binbuf_insert(b, 0L, 11, at);
+ }
+ binbuf_write(b, fn, vol, bin);
+ freeobject(b);
+ post("bonk~: wrote file %s", fn);
+ }
+
+ else
+ {
+ saveas_promptset("Save Template file as");
+ strcpy(fn, "");
+ if (!saveas_dialog(fn, &vol, 0L))
+ {
+ b = binbuf_new();
+ for (; ntemplate--; tp++)
+ {
+ int i;
+ Atom at[11];
+ for (i = 0; i < 11; i++)
+ at[i].a_type = A_FLOAT, at[i].a_w.w_float =
+ tp->t_amp[i];
+ binbuf_insert(b, 0L, 11, at);
+ }
+ binbuf_write(b, fn, vol, bin);
+ freeobject(b);
+ post("bonk~: wrote file %s", fn);
+ }
+ } // end of else
+}
+#endif /* MSP */
+
+static void bonk_free(t_bonk *x)
+{
+ int i, ninsig = x->x_ninsig;
+ t_insig *gp = x->x_insig;
+ for (i = 0, gp = x->x_insig; i < ninsig; i++, gp++)
+ freebytes(gp->g_inbuf, NPOINTS * sizeof(float));
+ clock_free(x->x_clock);
+}
+
+/* -------------------------- Pd glue ------------------------- */
+#ifdef PD
+
+static void *bonk_new(t_floatarg fperiod, t_floatarg fnsig)
+{
+ t_bonk *x = (t_bonk *)pd_new(bonk_class);
+ int nsig = fnsig, j;
+ t_insig *g;
+ if (nsig < 1) nsig = 1;
+ if (nsig > MAXCHANNELS) nsig = MAXCHANNELS;
+
+ x->x_clock = clock_new(x, (t_method)bonk_tick);
+ x->x_insig = (t_insig *)getbytes(nsig * sizeof(*x->x_insig));
+ for (j = 0, g = x->x_insig; j < nsig; j++, g++)
+ {
+ g->g_outlet = outlet_new(&x->x_obj, gensym("list"));
+ if (j)
+ inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_signal, &s_signal);
+ }
+ x->x_cookedout = outlet_new(&x->x_obj, gensym("list"));
+ bonk_donew(x, fperiod, nsig);
+ return (x);
+}
+
+void bonk_tilde_setup(void)
+{
+ bonk_class = class_new(gensym("bonk~"), (t_newmethod)bonk_new, 0,
+ sizeof(t_bonk), 0, A_DEFFLOAT, A_DEFFLOAT, 0);
+ class_addmethod(bonk_class, nullfn, gensym("signal"), 0);
+ class_addmethod(bonk_class, (t_method)bonk_dsp, gensym("dsp"), 0);
+ class_addbang(bonk_class, bonk_bang);
+ class_addmethod(bonk_class, (t_method)bonk_learn, gensym("learn"),
+ A_FLOAT, 0);
+ class_addmethod(bonk_class, (t_method)bonk_forget, gensym("forget"), 0);
+ class_addmethod(bonk_class, (t_method)bonk_thresh, gensym("thresh"),
+ A_FLOAT, A_FLOAT, 0);
+ class_addmethod(bonk_class, (t_method)bonk_mask, gensym("mask"),
+ A_FLOAT, A_FLOAT, 0);
+ class_addmethod(bonk_class, (t_method)bonk_debounce, gensym("debounce"),
+ A_FLOAT, 0);
+ class_addmethod(bonk_class, (t_method)bonk_minvel, gensym("minvel"),
+ A_FLOAT, 0);
+ class_addmethod(bonk_class, (t_method)bonk_print, gensym("print"),
+ A_DEFFLOAT, 0);
+ class_addmethod(bonk_class, (t_method)bonk_debug, gensym("debug"),
+ A_DEFFLOAT, 0);
+ class_addmethod(bonk_class, (t_method)bonk_read, gensym("read"),
+ A_SYMBOL, 0);
+ class_addmethod(bonk_class, (t_method)bonk_write, gensym("write"),
+ A_SYMBOL, 0);
+ bonk_setupkernels();
+ post("bonk version 1.1 TEST 3");
+}
+#endif
+
+/* -------------------------- MSP glue ------------------------- */
+#ifdef MSP
+
+static int ilog2(int n)
+{
+ int ret = -1;
+ while (n)
+ {
+ n >>= 1;
+ ret++;
+ }
+ return (ret);
+}
+
+static char *strcpy(char *s1, const char *s2)
+{
+ char *ret = s1;
+
+ while ((*s1++ = *s2++) != 0)
+ ;
+
+ return ret;
+}
+
+static void *bonk_new(int period, int nsig)
+{
+ int i, j;
+ t_hist *h;
+ t_bonk *x = (t_bonk *)newobject(bonk_class);
+ float *fp;
+ t_insig *g;
+
+ if (nsig < 1) nsig = 1;
+ if (nsig > MAXCHANNELS) nsig = MAXCHANNELS;
+ x->x_insig = (t_insig *)getbytes(nsig * sizeof(*x->x_insig));
+ dsp_setup((t_pxobject *)x, nsig); // nsig inputs
+ x->x_cookedout = listout((t_object *)x);
+ for (j = 0, g = x->x_insig + nsig-1; j < nsig; j++, g--)
+ {
+ g->g_outlet = listout((t_object *)x);
+ }
+ x->x_cookedout = listout((t_object *)x);
+ x->x_clock = clock_new(x, (method)bonk_tick);
+
+ bonk_donew(x, period, nsig);
+ return (x);
+}
+
+void main()
+{
+ setup(&bonk_class, bonk_new, (method)bonk_free,
+ (short)sizeof(t_bonk), 0L, A_DEFLONG, A_DEFLONG, 0);
+ addmess((method)bonk_dsp, "dsp", 0);
+ addbang((method)bonk_bang);
+ addmess((method)bonk_forget, "forget", 0);
+ addmess((method)bonk_learn, "learn", A_FLOAT, 0);
+ addmess((method)bonk_thresh, "thresh", A_FLOAT, A_FLOAT, 0);
+ addmess((method)bonk_mask, "mask", A_FLOAT, A_FLOAT, 0);
+ addmess((method)bonk_minvel, "minvel", A_FLOAT, 0);
+ addmess((method)bonk_debounce, "debounce", A_FLOAT, 0);
+ addmess((method)bonk_print, "print", A_DEFFLOAT, 0);
+ addmess((method)bonk_read, "read", A_DEFSYM, 0);
+ addmess((method)bonk_write, "write", A_DEFSYM, 0);
+ addmess((method)bonk_assist, "assist", A_CANT, 0);
+ addmess((method)bonk_debug, "debug", A_FLOAT, 0);
+ bonk_setupkernels();
+// post("bonk~ v1.00 Miller Puckette, Ted Apel");
+ post("bonk~ v1.00");
+ dsp_initclass();
+ rescopy('STR#',3747);
+}
+
+void bonk_assist(t_bonk *x, void *b, long m, long a, char *s)
+{
+ assist_string(3747,m,a,1,2,s);
+}
+
+ /* get current system time */
+double clock_getsystime()
+{
+
+ return gettime();
+}
+
+ /* elapsed time in milliseconds since the given system time */
+double clock_gettimesince(double prevsystime)
+{
+ return ((gettime() - prevsystime));
+}
+
+
+float qrsqrt(float f)
+{
+ return 1/sqrt(f);
+
+}
+#endif /* MSP */
diff --git a/pd/extra/bonk~/makefile b/pd/extra/bonk~/makefile
new file mode 100644
index 00000000..731e5cb3
--- /dev/null
+++ b/pd/extra/bonk~/makefile
@@ -0,0 +1,97 @@
+NAME=bonk~
+CSYM=bonk_tilde
+
+current: pd_linux
+
+# ----------------------- NT -----------------------
+
+pd_nt: $(NAME).dll
+
+.SUFFIXES: .dll
+
+PDNTCFLAGS = /W3 /WX /DNT /DPD /nologo
+VC="C:\Program Files\Microsoft Visual Studio\Vc98"
+
+PDNTINCLUDE = /I. /I\tcl\include /I\ftp\pd\src /I$(VC)\include
+
+PDNTLDIR = $(VC)\lib
+PDNTLIB = $(PDNTLDIR)\libc.lib \
+ $(PDNTLDIR)\oldnames.lib \
+ $(PDNTLDIR)\kernel32.lib \
+ \ftp\pd\bin\pd.lib
+
+.c.dll:
+ cl $(PDNTCFLAGS) $(PDNTINCLUDE) /c $*.c
+ link /dll /export:$(CSYM)_setup $*.obj $(PDNTLIB)
+
+# ----------------------- IRIX 5.x -----------------------
+
+pd_irix5: $(NAME).pd_irix5
+
+.SUFFIXES: .pd_irix5
+
+SGICFLAGS5 = -o32 -DPD -DUNIX -DIRIX -O2
+
+SGIINCLUDE = -I../../src
+
+.c.pd_irix5:
+ cc $(SGICFLAGS5) $(SGIINCLUDE) -o $*.o -c $*.c
+ ld -elf -shared -rdata_shared -o $*.pd_irix5 $*.o
+ rm -f $*.o ../$*.pd_linux
+ ln -s $*.pd_linux ..
+
+# ----------------------- IRIX 6.x -----------------------
+
+pd_irix6: $(NAME).pd_irix6
+
+.SUFFIXES: .pd_irix6
+
+SGICFLAGS6 = -n32 -DPD -DUNIX -DIRIX -DN32 -woff 1080,1064,1185 \
+ -OPT:roundoff=3 -OPT:IEEE_arithmetic=3 -OPT:cray_ivdep=true \
+ -Ofast=ip32
+
+.c.pd_irix6:
+ cc $(SGICFLAGS6) $(SGIINCLUDE) -o $*.o -c $*.c
+ ld -n32 -IPA -shared -rdata_shared -o $*.pd_irix6 $*.o
+ rm $*.o
+
+# ----------------------- LINUX i386 -----------------------
+
+pd_linux: $(NAME).pd_linux
+
+.SUFFIXES: .pd_linux
+
+LINUXCFLAGS = -fPIC -DPD -O2 -funroll-loops -fomit-frame-pointer \
+ -Wall -W -Wshadow -Wstrict-prototypes -Werror \
+ -Wno-unused -Wno-parentheses -Wno-switch
+
+LINUXINCLUDE = -I../../src
+
+LSTRIP = strip --strip-unneeded -R .note -R .comment
+
+.c.pd_linux:
+ cc $(LINUXCFLAGS) $(LINUXINCLUDE) -o $*.o -c $*.c
+ cc -Wl,-export_dynamic --shared -o $*.pd_linux $*.o -lm
+ $(LSTRIP) $*.pd_linux
+ rm -f $*.o ../$*.pd_linux
+ ln -s $*/$*.pd_linux ..
+
+# ----------------------- Mac OSX -----------------------
+
+pd_darwin: $(NAME).pd_darwin
+
+.SUFFIXES: .pd_darwin
+
+DARWINCFLAGS = -DPD -O2 -Wall -W -Wshadow -Wstrict-prototypes \
+ -Wno-unused -Wno-parentheses -Wno-switch
+
+.c.pd_darwin:
+ cc $(DARWINCFLAGS) $(LINUXINCLUDE) -o $*.o -c $*.c
+ cc -bundle -undefined suppress -flat_namespace -o $*.pd_darwin $*.o
+ rm -f $*.o ../$*.pd_darwin
+ ln -s $*/$*.pd_darwin ..
+
+# ----------------------------------------------------------
+
+clean:
+ rm -f *.o *.pd_* so_locations
diff --git a/pd/extra/bonk~/templates.txt b/pd/extra/bonk~/templates.txt
new file mode 100644
index 00000000..f3528d78
--- /dev/null
+++ b/pd/extra/bonk~/templates.txt
@@ -0,0 +1,4 @@
+ 10.47 9.65 14.95 23.77 28.32 38.84 53.21 41.20 31.25 21.70 16.48
+ 6.52 13.93 27.82 58.05 24.11 35.26 35.98 37.78 22.54 13.56 10.75
+ 30.45 28.86 29.42 21.94 29.92 35.70 38.49 32.01 28.19 27.38 22.10
+ 66.77 46.27 28.82 25.95 22.84 20.61 20.33 14.18 6.86 8.92 7.37
diff --git a/pd/extra/expr~/LICENSE.txt b/pd/extra/expr~/LICENSE.txt
new file mode 100644
index 00000000..a52b16e4
--- /dev/null
+++ b/pd/extra/expr~/LICENSE.txt
@@ -0,0 +1,341 @@
+
+ GNU GENERAL PUBLIC LICENSE
+ Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.
+ 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+ Preamble
+
+ The licenses for most software are designed to take away your
+freedom to share and change it. By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users. This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it. (Some other Free Software Foundation software is covered by
+the GNU Library General Public License instead.) You can apply it to
+your programs, too.
+
+ When we speak of free software, we are referring to freedom, not
+price. Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+ To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+ For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have. You must make sure that they, too, receive or can get the
+source code. And you must show them these terms so they know their
+rights.
+
+ We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+ Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software. If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+ Finally, any free program is threatened constantly by software
+patents. We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary. To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+ The precise terms and conditions for copying, distribution and
+modification follow.
+
+ GNU GENERAL PUBLIC LICENSE
+ TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+ 0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License. The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language. (Hereinafter, translation is included without limitation in
+the term "modification".) Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope. The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+ 1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+ 2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+ a) You must cause the modified files to carry prominent notices
+ stating that you changed the files and the date of any change.
+
+ b) You must cause any work that you distribute or publish, that in
+ whole or in part contains or is derived from the Program or any
+ part thereof, to be licensed as a whole at no charge to all third
+ parties under the terms of this License.
+
+ c) If the modified program normally reads commands interactively
+ when run, you must cause it, when started running for such
+ interactive use in the most ordinary way, to print or display an
+ announcement including an appropriate copyright notice and a
+ notice that there is no warranty (or else, saying that you provide
+ a warranty) and that users may redistribute the program under
+ these conditions, and telling the user how to view a copy of this
+ License. (Exception: if the Program itself is interactive but
+ does not normally print such an announcement, your work based on
+ the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole. If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works. But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+ 3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+ a) Accompany it with the complete corresponding machine-readable
+ source code, which must be distributed under the terms of Sections
+ 1 and 2 above on a medium customarily used for software interchange; or,
+
+ b) Accompany it with a written offer, valid for at least three
+ years, to give any third party, for a charge no more than your
+ cost of physically performing source distribution, a complete
+ machine-readable copy of the corresponding source code, to be
+ distributed under the terms of Sections 1 and 2 above on a medium
+ customarily used for software interchange; or,
+
+ c) Accompany it with the information you received as to the offer
+ to distribute corresponding source code. (This alternative is
+ allowed only for noncommercial distribution and only if you
+ received the program in object code or executable form with such
+ an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it. For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable. However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+ 4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License. Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+ 5. You are not required to accept this License, since you have not
+signed it. However, nothing else grants you permission to modify or
+distribute the Program or its derivative works. These actions are
+prohibited by law if you do not accept this License. Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+ 6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions. You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+ 7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License. If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all. For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices. Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+ 8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded. In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+ 9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time. Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number. If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation. If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+ 10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission. For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this. Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+ NO WARRANTY
+
+ 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+ 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+ END OF TERMS AND CONDITIONS
+
+ How to Apply These Terms to Your New Programs
+
+ If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+ To do so, attach the following notices to the program. It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+ <one line to give the program's name and a brief idea of what it does.>
+ Copyright (C) 19yy <name of author>
+
+ 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
+
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+ Gnomovision version 69, Copyright (C) 19yy name of author
+ Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+ This is free software, and you are welcome to redistribute it
+ under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License. Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary. Here is a sample; alter the names:
+
+ Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+ `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+ <signature of Ty Coon>, 1 April 1989
+ Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs. If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library. If this is what you want to do, use the GNU Library General
+Public License instead of this License.
diff --git a/pd/extra/expr~/README b/pd/extra/expr~/README
new file mode 100644
index 00000000..28fccf84
--- /dev/null
+++ b/pd/extra/expr~/README
@@ -0,0 +1,67 @@
+
+You can get more inofrmation on the expr object at
+http://www.crca.ucsd.edu/~yadegari/expr.html
+
+-----------
+
+New in Version 0.3
+-Full function functionality
+
+------------
+
+The object "expr" is used for expression evaluaion of control data.
+
+Expr~ and fexpr~ are extentions to the expr object to work with vectors.
+The expr~ object is designed to efficiently combine signal and control
+stream processing by vector operations on the basis of the block size of
+the environment.
+
+fexpr~ object provides a flexible mechanism for building FIR and
+IIR filters by evaluating expressions on a sample by sample basis
+and providing access to prior samples of the input and output audio
+streams. When fractional offset is used, fexpr~ uses linear interpolation
+to determine the value of the indexed sample. fexpr~ evaluates the
+expression for every single sample and at every evaluation previous
+samples (limited by the audio vector size) can be accessed. $x is used to
+denote a singnal input whose samples we would like to access. The syntax
+is $x followed by the inlet number and indexed by brackets, for example
+$x1[-1] specifies the previous sample of the first inlet. Therefore,
+if we are to build a simple filter which replaces every sample by
+the average of that sample and its previous one, we would use "fexpr~
+($x1[0]+$x1[-1])/2 ". For ease of when the brackets are omitted, the
+current sample is implied, so we can right the previous filter expression
+as follows: " fexpr~ ($x1+$x1[-1])/2". To build IIR filters $y is used
+to access the previous samples of the output stream.
+
+The three objects expr, expr~, and fexpr~ are implemented in the same object
+so the files expr~.pd_linux and fexpr~.pd_linux are links to expr.pd_linux
+This release has been compiled and tested on Linux 6.0.
+
+--------
+
+Here are some syntax information: (refer to help-expr.pd for examples)
+
+Syntyax:
+The syntax is very close to how expression are written in
+C. Variables are specified as follows where the '#' stands
+for the inlet number:
+$i#: integer input variable
+$f#: float input variable
+$s#: symbol input variable
+
+Used for expr~ only:
+$v#: signal (vector) input (vector by vector evaluation)
+
+Used for fexpr~ only:
+$x#[n]: the sample from inlet # indexed by n, where n has to
+ satisfy 0 => n >= -vector size,
+ ($x# is a shorthand for $x#[0], specifying the current sample)
+
+$y[n]: the output value indexed by n, where n has to
+ satisfy 0 > n >= -vector size,
+
+
+I'll appreciate hearing about bugs, comments, suggestions, ...
+
+Shahrokh Yadegari (sdy@ucsd.edu)
+1/29/02
diff --git a/pd/extra/expr~/fts_to_pd.h b/pd/extra/expr~/fts_to_pd.h
new file mode 100644
index 00000000..57b0382c
--- /dev/null
+++ b/pd/extra/expr~/fts_to_pd.h
@@ -0,0 +1,41 @@
+/* fts_to_pd.h -- alias some fts names to compile in Pd.
+
+copyright 1999 Miller Puckette;
+permission is granted to use this file for any purpose.
+*/
+
+
+#define fts_malloc malloc
+#define fts_calloc calloc
+#define fts_free free
+#define fts_realloc realloc
+#define fts_atom_t t_atom
+#define fts_object_t t_object
+typedef t_symbol *fts_symbol_t;
+
+#ifdef MSP
+#define t_atom Atom
+#define t_symbol Symbol
+#define pd_new(x) newobject(x);
+#define pd_free(x) freeobject(x);
+#define t_outlet void
+#define t_binbuf void
+typedef t_class *t_pd;
+typedef float t_floatarg;
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <string.h>
+#include <errno.h>
+
+void pd_error(void *object, char *fmt, ...);
+
+#endif /* MSP */
+
+#define post_error pd_error
+#define fts_is_floatg(x) ((x)->a_type == A_FLOAT)
+
+#define fts_new_symbol_copy gensym
+
+#define fts_symbol_name(x) ((x)->s_name)
diff --git a/pd/extra/expr~/help-expr.pd b/pd/extra/expr~/help-expr.pd
new file mode 100644
index 00000000..98ca696f
--- /dev/null
+++ b/pd/extra/expr~/help-expr.pd
@@ -0,0 +1,231 @@
+#N canvas 0 0 1024 745 10;
+#X obj 75 416 expr 1;
+#X floatatom 239 384 0 0 0;
+#X floatatom 75 446 0 0 0;
+#X msg 75 388 bang;
+#X obj 143 414 expr 2 + 3;
+#X msg 143 387 bang;
+#X floatatom 143 442 0 0 0;
+#X floatatom 238 442 0 0 0;
+#X obj 238 414 expr 2+$f1;
+#X floatatom 76 485 0 0 0;
+#X floatatom 76 542 0 0 0;
+#X obj 76 514 expr $f1 * $f2;
+#X floatatom 155 485 0 0 0;
+#N canvas 0 0 450 300 graph1 0;
+#X coords 0 10 10 0 200 150 1;
+#X array array1 10 float 0;
+#X restore 472 362 graph;
+#X floatatom 77 580 0 0 0;
+#X floatatom 77 636 0 0 0;
+#X floatatom 236 484 0 0 0;
+#X floatatom 236 541 0 0 0;
+#X obj 236 513 expr $s2[$f1];
+#X msg 309 485 symbol array1;
+#X obj 77 608 expr sin(2 * 3.14159 * $f1 / 360);
+#X msg 429 554 \; array1 1 4 2 8 5 6 1 4 2 8 5 6;
+#X text 81 345 expr examples:;
+#X text 66 10 expression evaluation family - expr \, expr~ \, fexpr~
+;
+#X text 66 188 Syntyax:;
+#X text 67 260 $f#: float input variable;
+#X text 68 275 $s#: symbol input variable;
+#X text -37 708 expr~ examples:;
+#X obj 30 911 print~;
+#X msg 67 890 bang;
+#X obj 30 832 sig~ 440;
+#X floatatom 103 849 0 0 0;
+#X floatatom 30 809 0 0 0;
+#X obj 30 872 expr~ $v1*$f2;
+#X obj 139 912 print~;
+#X msg 155 891 bang;
+#X floatatom 139 824 0 0 0;
+#X floatatom 212 826 0 0 0;
+#X floatatom 411 847 0 0 0;
+#X floatatom 298 823 0 0 0;
+#X obj 298 850 osc~;
+#X msg 526 670 \; pd dsp 0;
+#X msg 448 672 \; pd dsp 1;
+#X text 451 649 audio on;
+#X text 534 648 audio off;
+#X text 274 314 comment;
+#X text 9 792 vector times scalar;
+#X text 141 792 vector;
+#X obj 297 910 dac~;
+#X text 295 801 frequency;
+#X text 427 829 amplitude;
+#X text 497 116 Used for expr~ only:;
+#X text 499 139 $v#: signal (vector) input (vector by vector evaluation)
+;
+#X text 494 172 Used for fexpr~ only:;
+#X text 495 242 $y[n]: the output value indexed by n where n has to
+satisfy 0 > n >= -vector size.;
+#X text 489 282 (the vector size can be changed by the "block~" object.)
+;
+#X text 493 191 $x#[n]: the sample from inlet # indexed by n where
+n has to satisfy 0 => n >= -vector size \, ($x# is a shorthand for
+$x#[0] \, specifying the current sample);
+#X floatatom 81 1300 0 0 0;
+#X floatatom 214 1319 0 0 0;
+#X msg 181 1279 -10;
+#X text 8 1099 fexpr~ examples:;
+#X obj 80 1567 print~;
+#X msg 88 1547 bang;
+#X floatatom 80 1471 0 0 0;
+#X obj 80 1500 sig~ 1;
+#X obj 81 1343 fexpr~ ($x1[$f2]+$x1)/2;
+#X obj 80 1528 fexpr~ $x1+$y[-1];
+#X floatatom 590 1362 0 0 0;
+#X floatatom 750 1383 0 0 0;
+#X obj 585 1452 dac~;
+#X obj 587 1403 fexpr~ ($x1[$f2/1000]+$x1)/2;
+#X msg 819 1313 0 10000;
+#X obj 750 1364 line 0;
+#X msg 753 1314 -10000;
+#X obj 75 1385 dac~;
+#X text 51 1223 Simple FIR filter;
+#X text 512 1130 Simple FIR filter using fractional offset;
+#X msg 659 1314 -10000 10000;
+#X obj 590 1383 osc~ 2205;
+#X msg 599 1339 1102.5;
+#X msg 817 1338 0 10000;
+#X msg 751 1339 -20000;
+#X msg 657 1339 -20000 10000;
+#X msg 590 1314 2205;
+#X text 88 1611 end;
+#X msg 503 1308 start;
+#X msg 505 1330 stop;
+#X msg 12 1280 start;
+#X msg 11 1305 stop;
+#X msg 30 1465 start;
+#X msg 29 1490 stop;
+#X obj 446 1331 loadbang;
+#X obj -27 1491 loadbang;
+#X obj -44 1305 loadbang;
+#X text 572 1287 frequency;
+#X text 662 1296 of the simple filter;
+#X msg 248 1278 -20;
+#X obj 81 1321 osc~ 2205;
+#X msg 111 1277 1102.5;
+#X msg 65 1277 2205;
+#X msg 215 1278 0;
+#X text 78 1441 simple accumulator defined as and an IIR filter;
+#X obj 139 871 expr~ $v1*$v2;
+#X text 7 1144 NOTE: fexpr~ could use lots of CPU power \, by default
+fexpr~ is on when it is loaded. In this page we are turning them off
+with loadbang \, so to hear them you have to turn them on explicitly.
+You can use the "start" and "stop" messages to start and stop fexpr~
+and expr~;
+#X text 65 101 expr~ is used for expression evaluaion of signal data
+on the vector by vector basis;
+#X text 66 85 expr is used for expression evaluaion of control data
+;
+#X text 661 1284 index defining the frequency;
+#X text 50 1236 -10 offset will fully filter audio frequency of 2205
+\, and -20 offset will filter audio at frequency of 1102.5;
+#X text 514 1211 Thus \, the offset -10000 will filter audio at frequency
+of 2205 and the offset value -20000 will filter the audio at frequency
+of 1102.5.;
+#X text 513 1157 When fractional offset is used \, fexpr~ determines
+indexed by linear interpolation. In the following example the offset
+value is divided by 1000 \, thus we can continuously change the offset
+without an audible click in the output.;
+#X text 243 1314 If you change this value you;
+#X text 245 1326 hear a click;
+#X text 77 670 make sure you turn on audio for the expr~ and fexpr~
+examples;
+#X text 64 38 For a more detailed documentaion refer to http://www.crca.ucsd.edu/~yadegari/expr.html
+;
+#X text 67 203 The syntax is very close to how expressions are written
+in C. Variables are specified as follows where the '#' stands for the
+inlet number:;
+#X text 68 246 $i#: integer input variable;
+#X text 67 138 fexpr~ is used for expression evaluaion on sample level
+data \; i.e. \, filter design. Warning: fexpr~ is very cpu intensive.
+;
+#X floatatom 792 826 5 0 0;
+#X obj 545 875 tabsend~ a1;
+#N canvas 0 0 450 300 graph4 0;
+#X coords 0 1 63 -1 200 140 1;
+#X array a1 64 float 0;
+#X restore 546 897 graph;
+#X obj 545 852 expr~ max(min($v1 \, $f2/10) \, -$f2/10);
+#X obj 545 828 osc~ 4000;
+#X text 13 730 NOTES: the first inlet of expr~ cannot be a $f1 or $i1
+\, this may change in later releases;
+#X text 535 775 A simple limiter example;
+#X text 718 800 Move the value below between 0 and 10 to change the
+limiter threshold;
+#X obj 410 714 vsl 15 128 0 127 0 0 empty empty empty 20 8 0 8 -262144
+-1 -1 0 1;
+#X obj 297 871 expr~ $v1*$f2/128;
+#X text 641 12 updated for Pd 0.35-35 test 8 and expr* 0.3;
+#X connect 0 0 2 0;
+#X connect 1 0 8 0;
+#X connect 3 0 0 0;
+#X connect 4 0 6 0;
+#X connect 5 0 4 0;
+#X connect 8 0 7 0;
+#X connect 9 0 11 0;
+#X connect 11 0 10 0;
+#X connect 12 0 11 1;
+#X connect 14 0 20 0;
+#X connect 16 0 18 0;
+#X connect 18 0 17 0;
+#X connect 19 0 18 1;
+#X connect 20 0 15 0;
+#X connect 29 0 28 0;
+#X connect 30 0 33 0;
+#X connect 31 0 33 1;
+#X connect 32 0 30 0;
+#X connect 33 0 28 0;
+#X connect 35 0 34 0;
+#X connect 36 0 102 0;
+#X connect 37 0 102 1;
+#X connect 38 0 126 1;
+#X connect 39 0 40 0;
+#X connect 40 0 126 0;
+#X connect 57 0 97 0;
+#X connect 58 0 65 1;
+#X connect 59 0 58 0;
+#X connect 62 0 61 0;
+#X connect 63 0 64 0;
+#X connect 64 0 66 0;
+#X connect 65 0 74 0;
+#X connect 65 0 74 1;
+#X connect 66 0 61 0;
+#X connect 67 0 78 0;
+#X connect 68 0 70 1;
+#X connect 70 0 69 0;
+#X connect 70 0 69 1;
+#X connect 71 0 72 0;
+#X connect 72 0 68 0;
+#X connect 73 0 72 0;
+#X connect 77 0 72 0;
+#X connect 78 0 70 0;
+#X connect 79 0 67 0;
+#X connect 80 0 72 0;
+#X connect 81 0 72 0;
+#X connect 82 0 72 0;
+#X connect 83 0 67 0;
+#X connect 85 0 70 0;
+#X connect 86 0 70 0;
+#X connect 87 0 65 0;
+#X connect 88 0 65 0;
+#X connect 89 0 66 0;
+#X connect 90 0 66 0;
+#X connect 91 0 86 0;
+#X connect 92 0 90 0;
+#X connect 93 0 88 0;
+#X connect 96 0 58 0;
+#X connect 97 0 65 0;
+#X connect 98 0 57 0;
+#X connect 99 0 57 0;
+#X connect 100 0 58 0;
+#X connect 102 0 34 0;
+#X connect 117 0 120 1;
+#X connect 120 0 118 0;
+#X connect 121 0 120 0;
+#X connect 125 0 38 0;
+#X connect 126 0 48 0;
+#X connect 126 0 48 1;
diff --git a/pd/extra/expr~/makefile b/pd/extra/expr~/makefile
new file mode 100644
index 00000000..d0175a8a
--- /dev/null
+++ b/pd/extra/expr~/makefile
@@ -0,0 +1,160 @@
+
+current: expr.pd_linux expr~.pd_linux fexpr~.pd_linux
+
+install: install_linux
+
+clean: clean_linux
+
+clobber: clobber_linux
+
+PDEXTERN=/usr/local/lib/pd/externs
+
+# ----------------------- NT -----------------------
+
+pd_nt: expr.dll
+
+NTOBJ = vexp.obj vexp_fun.obj vexp_if.obj
+
+PDNTCFLAGS = /W3 /WX /DNT /DPD /nologo
+VC="C:\Program Files\Microsoft Visual Studio\Vc98"
+
+PDNTINCLUDE = /I. /I\tcl\include /I\ftp\pd\src /I$(VC)\include
+
+PDNTLDIR = $(VC)\lib
+PDNTLIB = $(PDNTLDIR)\libc.lib \
+ $(PDNTLDIR)\oldnames.lib \
+ $(PDNTLDIR)\kernel32.lib \
+ \ftp\pd\bin\pd.lib
+
+.c.obj:
+ cl $(PDNTCFLAGS) $(PDNTINCLUDE) /c $*.c
+
+expr.dll: $(NTOBJ)
+ link /dll /export:expr_setup /export:expr_tilde_setup \
+ /export:fexpr_tilde_setup $(NTOBJ) $(PDNTLIB)
+ ren vexp.dll expr.dll
+ copy expr.dll ..\expr.dll
+ copy expr.dll ..\expr~.dll
+ copy expr.dll ..\fexpr~.dll
+ copy help-expr.pd ..\help-expr.pd
+
+# ----------------------- IRIX 5.x -----------------------
+
+pd_irix5:
+
+.SUFFIXES: .pd_irix5
+
+SGICFLAGS5 = -o32 -DPD -DSGI -O2
+
+
+SGIINCLUDE = -I/usr/people/msp/pd/pd/src
+
+.c.pd_irix5:
+ cc $(SGICFLAGS5) $(SGIINCLUDE) -o $*.o -c $*.c
+ ld -elf -shared -rdata_shared -o $*.pd_irix5 $*.o
+ rm $*.o
+
+# ----------------------- IRIX 6.x -----------------------
+
+pd_irix6:
+
+.SUFFIXES: .pd_irix6
+
+SGICFLAGS6 = -DPD -DSGI -n32 \
+ -OPT:roundoff=3 -OPT:IEEE_arithmetic=3 -OPT:cray_ivdep=true \
+ -Ofast=ip32
+
+SGICFLAGS5 = -DPD -O2 -DSGI
+
+SGIINCLUDE = -I/usr/people/msp/pd/pd/src
+
+.c.pd_irix6:
+ cc $(SGICFLAGS6) $(SGIINCLUDE) -o $*.o -c $*.c
+ ld -elf -shared -rdata_shared -o $*.pd_irix6 $*.o
+ rm $*.o
+
+# ----------------------- LINUX i386 -----------------------
+
+LINUXOBJ = vexp.pd_linux_o vexp_fun.pd_linux_o vexp_if.pd_linux_o
+.SUFFIXES: .pd_linux_o
+
+LINUXCFLAGS = -DPD -O2 -funroll-loops -fomit-frame-pointer \
+ -Wall -W -Wshadow -Wstrict-prototypes -Werror \
+ -Wno-unused -Wno-parentheses -Wno-switch
+
+LINUXINCLUDE = -I../../src
+
+.c.pd_linux_o:
+ cc -g $(LINUXCFLAGS) $(LINUXINCLUDE) -o $*.pd_linux_o -c $*.c
+
+expr.pd_linux: $(LINUXOBJ)
+ ld -export_dynamic -shared -o expr.pd_linux $(LINUXOBJ) -lc -lm
+ strip --strip-unneeded expr.pd_linux
+ rm -f ../expr.pd_linux
+ ln -s expr~/expr.pd_linux ..
+
+expr~.pd_linux: expr.pd_linux
+ ln -s expr.pd_linux expr~.pd_linux
+ ln -s expr~/expr~.pd_linux ..
+
+fexpr~.pd_linux: expr.pd_linux
+ ln -s expr.pd_linux fexpr~.pd_linux
+ ln -s expr~/fexpr~.pd_linux ..
+
+install_linux:
+ install expr.pd_linux $(PDEXTERN)
+ rm -f $(PDEXTERN)/expr~.pd_linux
+ rm -f $(PDEXTERN)/fexpr~.pd_linux
+ cd $(PDEXTERN); \
+ ln -s expr.pd_linux expr~.pd_linux; \
+ ln -s expr.pd_linux fexpr~.pd_linux
+
+linux_clean:
+ rm -f *.pd_linux_o *.o
+
+linux_clobber: clean
+ rm -f expr.pd_linux expr.pd_irix6
+
+# ----------------------- MAC OSX -----------------------
+
+pd_darwin: expr.pd_darwin expr~.pd_darwin fexpr~.pd_darwin
+MACOSXOBJ = vexp.pd_darwin_o vexp_fun.pd_darwin_o vexp_if.pd_darwin_o
+.SUFFIXES: .pd_darwin_o
+
+MACOSXCFLAGS = -DMACOSX -DPD -O2 -Wall -W -Wshadow -Wstrict-prototypes \
+ -Wno-unused -Wno-parentheses -Wno-switch
+
+MACOSXINCLUDE = -I../../src
+
+.c.pd_darwin_o:
+ cc -g $(MACOSXCFLAGS) $(MACOSXINCLUDE) -o $*.pd_darwin_o -c $*.c
+
+expr.pd_darwin: $(MACOSXOBJ)
+ cc -bundle -undefined suppress -flat_namespace \
+ -o expr.pd_darwin $(MACOSXOBJ) -lm
+ rm -f ../expr.pd_darwin
+ ln -s expr~/expr.pd_darwin ..
+
+expr~.pd_darwin: expr.pd_darwin
+ ln -s expr.pd_darwin expr~.pd_darwin
+ rm -f ../expr~.pd_darwin
+ ln -s expr~/expr~.pd_darwin ..
+
+fexpr~.pd_darwin: expr.pd_darwin
+ ln -s expr.pd_darwin fexpr~.pd_darwin
+ rm -f ../fexpr~.pd_darwin
+ ln -s expr~/fexpr~.pd_darwin ..
+
+install_darwin:
+ install expr.pd_darwin $(PDEXTERN)
+ rm -f $(PDEXTERN)/expr~.pd_darwin
+ rm -f $(PDEXTERN)/fexpr~.pd_darwin
+ cd $(PDEXTERN); \
+ ln -s expr.pd_darwin expr~.pd_darwin; \
+ ln -s expr.pd_darwin fexpr~.pd_darwin
+
+darwin_clean:
+ rm -f *.pd_darwin_o *.o
+
+darwin_clobber: clean
+ rm -f expr.pd_darwin expr.pd_irix6
diff --git a/pd/extra/expr~/vexp.c b/pd/extra/expr~/vexp.c
new file mode 100644
index 00000000..dddf6efa
--- /dev/null
+++ b/pd/extra/expr~/vexp.c
@@ -0,0 +1,1948 @@
+/*
+ * jMax
+ * Copyright (C) 1994, 1995, 1998, 1999 by IRCAM-Centre Georges Pompidou, Paris, France.
+ *
+ * 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.
+ *
+ * See file LICENSE for further informations on licensing terms.
+ *
+ * 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.
+ *
+ * Based on Max/ISPW by Miller Puckette.
+ *
+ * Authors: Maurizio De Cecco, Francois Dechelle, Enzo Maggi, Norbert Schnell.
+ *
+ */
+
+/* "expr" was written by Shahrokh Yadegari c. 1989. -msp */
+/* "expr~" and "fexpr~" conversion by Shahrokh Yadegari c. 1999,2000 */
+
+/*
+ * vexp.c -- a variable expression evaluator
+ *
+ * This modules implements an expression evaluator using the
+ * operator-precedence parsing. It transforms an infix expression
+ * to a prefix stack ready to be evaluated. The expression sysntax
+ * is close to that of C. There are a few operators that are not
+ * supported and functions are also recognized. Strings can be
+ * passed to functions when they are quoted in '"'s. "[]" are implememted
+ * as an easy way of accessing the content of tables, and the syntax
+ * table_name[index].
+ * Variables (inlets) are specified with the following syntax: $x#,
+ * where x is either i(integers), f(floats), and s(strings); and #
+ * is a digit that coresponds to the inlet number. The string variables
+ * can be used as strings when they are quoted and can also be used as
+ * table names when they are followed by "[]".
+ *
+ * signal vectors have been added to this implementation:
+ * $v# denotes a signal vector
+ * $x#[index] is the value of a sample at the index of a the signal vector
+ * $x# is the shorthand for $x#[0]
+ * $y[index] is the value of the sample output at the index of a the
+ * signal output
+ * "index" for $x#[index] has to have this range (0 <= index < vectorsize)
+ * "index" for $y[index] has to have this range (0 < index < vectorsize)
+ */
+
+#include <string.h>
+#include <stdlib.h>
+#include "vexp.h"
+
+#ifndef MSP
+#ifndef MACOSX
+/*
+ *stdlib.h produces a redefinition of _alloca()
+ * why, I do not know?
+ */
+#include "stdlib.h"
+#endif
+#endif
+char *atoif(char *s, long int *value, long int *type);
+
+static struct ex_ex *ex_lex(struct expr *exp, long int *n);
+struct ex_ex *ex_match(struct ex_ex *eptr, long int op);
+struct ex_ex *ex_parse(struct expr *exp, struct ex_ex *iptr,
+ struct ex_ex *optr, long int *argc);
+struct ex_ex *ex_eval(struct expr *exp, struct ex_ex *eptr,
+ struct ex_ex *optr, int i);
+
+int expr_donew(struct expr *expr, int ac, t_atom *av);
+struct ex_ex *eval_func(struct expr *exp,struct ex_ex *eptr,
+ struct ex_ex *optr, int i);
+struct ex_ex *eval_tab(struct expr *exp, struct ex_ex *eptr,
+ struct ex_ex *optr, int i);
+struct ex_ex *eval_sigidx(struct expr *exp, struct ex_ex *eptr,
+ struct ex_ex *optr, int i);
+static int cal_sigidx(struct ex_ex *optr, /* The output value */
+ int i, float rem_i, /* integer and fractinal part of index */
+ int idx, /* index of current fexpr~ processing */
+ int vsize, /* vector size */
+ float *curvec, float *prevec); /* current and previous table */
+t_ex_func *find_func(char *s);
+void ex_dzdetect(struct expr *exp);
+
+#define MAX_ARGS 10
+extern t_ex_func ex_funcs[];
+
+struct ex_ex nullex;
+
+void set_tokens (char *s);
+int getoken (struct expr *exp, struct ex_ex *eptr);
+void ex_print (struct ex_ex *eptr);
+#ifdef MSP
+void atom_string(t_atom *a, char *buf, unsigned int bufsize);
+
+void atom_string(t_atom *a, char *buf, unsigned int bufsize)
+{
+ char tbuf[30];
+ switch(a->a_type)
+ {
+ case A_SEMI: strcpy(buf, ";"); break;
+ case A_COMMA: strcpy(buf, ","); break;
+#ifdef PD
+ case A_POINTER:
+ strcpy(buf, "(pointer)");
+ break;
+#endif
+ case A_FLOAT:
+ sprintf(tbuf, "%g", a->a_w.w_float);
+ if (strlen(tbuf) < bufsize-1) strcpy(buf, tbuf);
+ else if (a->a_w.w_float < 0) strcpy(buf, "-");
+ else strcat(buf, "+");
+ break;
+ case A_LONG:
+ sprintf(tbuf, "%d", a->a_w.w_long);
+ if (strlen(tbuf) < bufsize-1) strcpy(buf, tbuf);
+ else if (a->a_w.w_float < 0) strcpy(buf, "-");
+ else strcat(buf, "+");
+ break;
+ case A_SYMBOL:
+ {
+ char *sp;
+ unsigned int len;
+ int quote;
+ for (sp = a->a_w.w_symbol->s_name, len = 0, quote = 0; *sp; sp++, len++)
+ if (*sp == ';' || *sp == ',' || *sp == '\\' ||
+ (*sp == '$' && sp == a->a_w.w_symbol->s_name && sp[1] >= '0'
+ && sp[1] <= '9'))
+ quote = 1;
+ if (quote)
+ {
+ char *bp = buf, *ep = buf + (bufsize-2);
+ sp = a->a_w.w_symbol->s_name;
+ while (bp < ep && *sp)
+ {
+ if (*sp == ';' || *sp == ',' || *sp == '\\' ||
+ (*sp == '$' && bp == buf && sp[1] >= '0' && sp[1] <= '9'))
+ *bp++ = '\\';
+ *bp++ = *sp++;
+ }
+ if (*sp) *bp++ = '*';
+ *bp = 0;
+ /* post("quote %s -> %s", a->a_w.w_symbol->s_name, buf); */
+ }
+ else
+ {
+ if (len < bufsize-1) strcpy(buf, a->a_w.w_symbol->s_name);
+ else
+ {
+ strncpy(buf, a->a_w.w_symbol->s_name, bufsize - 2);
+ strcpy(buf + (bufsize - 2), "*");
+ }
+ }
+ }
+ break;
+#ifdef PD
+ case A_DOLLAR:
+ sprintf(buf, "$%d", a->a_w.w_index);
+ break;
+ case A_DOLLSYM:
+ sprintf(buf, "$%s", a->a_w.w_symbol->s_name);
+ break;
+#else /* MAX */
+ case A_DOLLAR:
+ sprintf(buf, "$%s", a->a_w.w_symbol->s_name);
+ break;
+#endif
+ default:
+ post("atom_string bug");
+ }
+}
+#endif /* MSP */
+/*
+ * expr_donew -- create a new "expr" object.
+ * returns 1 on failure, 0 on success.
+ */
+int
+expr_donew(struct expr *expr, int ac, t_atom *av)
+{
+ struct ex_ex *list;
+ struct ex_ex *ret;
+ long max_node = 0; /* maximum number of nodes needed */
+ char *exp_string;
+ int exp_strlen;
+ t_binbuf *b;
+
+ memset(expr->exp_var, 0, MAX_VARS * sizeof (*expr->exp_var));
+#ifdef PD
+ b = binbuf_new();
+ binbuf_add(b, ac, av);
+ binbuf_gettext(b, &exp_string, &exp_strlen);
+
+#else /* MSP */
+{
+ char *buf = getbytes(0), *newbuf;
+ int length = 0;
+ char string[250];
+ t_atom *ap;
+ int indx;
+
+ for (ap = av, indx = 0; indx < ac; indx++, ap = ++av) {
+ int newlength;
+ if ((ap->a_type == A_SEMI || ap->a_type == A_COMMA) &&
+ length && buf[length-1] == ' ') length--;
+ atom_string(ap, string, 250);
+ newlength = length + strlen(string) + 1;
+ if (!(newbuf = t_resizebytes(buf, length, newlength))) break;
+ buf = newbuf;
+ strcpy(buf + length, string);
+ length = newlength;
+ if (ap->a_type == A_SEMI) buf[length-1] = '\n';
+ else buf[length-1] = ' ';
+ }
+
+ if (length && buf[length-1] == ' ') {
+ if (newbuf = t_resizebytes(buf, length, length-1))
+ {
+ buf = newbuf;
+ length--;
+ }
+ }
+ exp_string = buf;
+ exp_strlen = length;
+}
+#endif
+ exp_string = (char *)t_resizebytes(exp_string, exp_strlen,exp_strlen+1);
+ exp_string[exp_strlen] = 0;
+ set_tokens(exp_string);
+ list = ex_lex(expr, &max_node);
+ set_tokens((char *)0);
+ if (!list) { /* syntax error */
+ return (1);
+ }
+ expr->exp_stack = (struct ex_ex *)fts_malloc(max_node *
+ sizeof (struct ex_ex));
+ ret = ex_match(list, (long)0);
+ if (!ret) /* syntax error */
+ goto error;
+ ret = ex_parse(expr, list, expr->exp_stack, (long *)0);
+ if (ret) {
+ *ret = nullex;
+ /* print the stack that been built */
+ t_freebytes(exp_string, exp_strlen+1);
+ return (0);
+ }
+error:
+ fts_free(expr->exp_stack);
+ expr->exp_stack = 0;
+ fts_free(list);
+ t_freebytes(exp_string, exp_strlen+1);
+ return (1);
+}
+
+/*
+ * ex_lex -- This routine is a bit more than a lexical parser since it will
+ * also do some syntax checking. It reads the string s and will
+ * return a linked list of struct ex_ex.
+ * It will also put the number of the nodes in *n.
+ */
+struct ex_ex *
+ex_lex(struct expr *exp, long int *n)
+{
+ struct ex_ex *list_arr;
+ struct ex_ex *exptr;
+ long non = 0; /* number of nodes */
+ long maxnode = 0;
+
+ list_arr = (struct ex_ex *)fts_malloc(sizeof (struct ex_ex) * MINODES);
+ if (! list_arr) {
+ post("ex_lex: no mem\n");
+ return ((struct ex_ex *)0);
+ }
+ exptr = list_arr;
+ maxnode = MINODES;
+
+ while (8)
+ {
+ if (non >= maxnode) {
+ maxnode += MINODES;
+
+ list_arr = fts_realloc((void *)list_arr,
+ sizeof (struct ex_ex) * maxnode);
+ if (!list_arr) {
+ post("ex_lex: no mem\n");
+ return ((struct ex_ex *)0);
+ }
+ exptr = &(list_arr)[non];
+ }
+
+ if (getoken(exp, exptr)) {
+ fts_free(list_arr);
+ return ((struct ex_ex *)0);
+ }
+ non++;
+
+ if (!exptr->ex_type)
+ break;
+
+ exptr++;
+ }
+ *n = non;
+
+ return list_arr;
+}
+
+/*
+ * ex_match -- this routine walks through the eptr and matches the
+ * perentheses and brackets, it also converts the function
+ * names to a pointer to the describing structure of the
+ * specified function
+ */
+/* operator to match */
+struct ex_ex *
+ex_match(struct ex_ex *eptr, long int op)
+{
+ int firstone = 1;
+ struct ex_ex *ret;
+ t_ex_func *fun;
+
+ for (; 8; eptr++, firstone = 0) {
+ switch (eptr->ex_type) {
+ case 0:
+ if (!op)
+ return (eptr);
+ post("expr syntax error: an open %s not matched\n",
+ op == OP_RP ? "parenthesis" : "bracket");
+ return (exNULL);
+ case ET_INT:
+ case ET_FLT:
+ case ET_II:
+ case ET_FI:
+ case ET_SI:
+ case ET_VI:
+ case ET_SYM:
+ case ET_VSYM:
+ case ET_VO:
+ continue;
+ case ET_XI:
+ if (eptr[1].ex_type != ET_OP || eptr[1].ex_op != OP_LB)
+ eptr->ex_type = ET_XI0;
+ continue;
+ case ET_TBL:
+ case ET_FUNC:
+ case ET_LP:
+ /* CHANGE
+ case ET_RP:
+ */
+ case ET_LB:
+ /* CHANGE
+ case ET_RB:
+ */
+ post("ex_match: unexpected type, %ld\n", eptr->ex_type);
+ return (exNULL);
+ case ET_OP:
+ if (op == eptr->ex_op)
+ return (eptr);
+ /*
+ * if we are looking for a right peranthesis
+ * or a right bracket and find the other kind,
+ * it has to be a syntax error
+ */
+ if ((eptr->ex_op == OP_RP && op == OP_RB) ||
+ (eptr->ex_op == OP_RB && op == OP_RP)) {
+ post("expr syntax error: prenthesis or brackets not matched\n");
+ return (exNULL);
+ }
+ /*
+ * Up to now we have marked the unary minuses as
+ * subrtacts. Any minus that is the first one in
+ * chain or is preceeded by anything except ')' and
+ * ']' is a unary minus.
+ */
+ if (eptr->ex_op == OP_SUB) {
+ ret = eptr - 1;
+ if (firstone || (ret->ex_type == ET_OP &&
+ ret->ex_op != OP_RB && ret->ex_op != OP_RP))
+ eptr->ex_op = OP_UMINUS;
+ } else if (eptr->ex_op == OP_LP) {
+ ret = ex_match(eptr + 1, OP_RP);
+ if (!ret)
+ return (ret);
+ eptr->ex_type = ET_LP;
+ eptr->ex_ptr = (char *) ret;
+ eptr = ret;
+ } else if (eptr->ex_op == OP_LB) {
+ ret = ex_match(eptr + 1, OP_RB);
+ if (!ret)
+ return (ret);
+ eptr->ex_type = ET_LB;
+ eptr->ex_ptr = (char *) ret;
+ eptr = ret;
+ }
+ continue;
+ case ET_STR:
+ if (eptr[1].ex_type != ET_OP) {
+ post("expr: syntax error: bad string '%s'\n", eptr->ex_ptr);
+ return (exNULL);
+ }
+ if (eptr[1].ex_op == OP_LB) {
+ char *tmp;
+
+ eptr->ex_type = ET_TBL;
+ tmp = eptr->ex_ptr;
+ if (ex_getsym(tmp, (t_symbol **)&(eptr->ex_ptr))) {
+ post("expr: syntax error: problms with ex_getsym\n");
+ return (exNULL);
+ }
+ fts_free((void *)tmp);
+ } else if (eptr[1].ex_op == OP_LP) {
+ fun = find_func(eptr->ex_ptr);
+ if (!fun) {
+ post(
+ "expr: error: function %s not found\n",
+ eptr->ex_ptr);
+ return (exNULL);
+ }
+ eptr->ex_type = ET_FUNC;
+ eptr->ex_ptr = (char *) fun;
+ } else {
+ post("expr: syntax error: bad string '%s'\n", eptr->ex_ptr);
+ return (exNULL);
+ }
+ continue;
+ default:
+ post("ex_match: bad type\n");
+ return (exNULL);
+ }
+ }
+ /* NOTREACHED */
+}
+
+/*
+ * ex_parse -- This function if called when we have already done some
+ * parsing on the expression, and we have already matched
+ * our brackets and parenthesis. The main job of this
+ * function is to convert the infix expression to the
+ * prefix form.
+ * First we find the operator with the lowest precedence and
+ * put it on the stack ('optr', it is really just an array), then
+ * we call ourself (ex_parse()), on its arguments (unary operators
+ * only have one operator.)
+ * When "argc" is set it means that we are parsing the arguments
+ * of a function and we will increment *argc anytime we find
+ * a a segment that can qualify as an argument (counting commas).
+ *
+ * returns 0 on syntax error
+ */
+/* number of argument separated by comma */
+struct ex_ex *
+ex_parse(struct expr *x, struct ex_ex *iptr, struct ex_ex *optr, long int *argc)
+{
+ struct ex_ex *eptr;
+ struct ex_ex *lowpre = 0; /* pointer to the lowest precedence */
+ struct ex_ex savex;
+ long pre = HI_PRE;
+ long count;
+
+ if (!iptr) {
+ post("ex_parse: input is null, iptr = 0x%lx\n", iptr);
+ return (exNULL);
+ }
+ if (!iptr->ex_type)
+ return (exNULL);
+
+ /*
+ * the following loop finds the lowest precedence operator in the
+ * the input token list, comma is explicitly checked here since
+ * that is a special operator and is only legal in functions
+ */
+ for (eptr = iptr, count = 0; eptr->ex_type; eptr++, count++)
+ switch (eptr->ex_type) {
+ case ET_SYM:
+ case ET_VSYM:
+ if (!argc) {
+ post("expr: syntax error: symbols allowed for functions only\n");
+ ex_print(eptr);
+ return (exNULL);
+ }
+ case ET_INT:
+ case ET_FLT:
+ case ET_II:
+ case ET_FI:
+ case ET_XI0:
+ case ET_VI:
+ if (!count && !eptr[1].ex_type) {
+ *optr++ = *eptr;
+ return (optr);
+ }
+ break;
+ case ET_XI:
+ case ET_VO:
+ case ET_SI:
+ case ET_TBL:
+ if (eptr[1].ex_type != ET_LB) {
+ post("expr: syntax error: brackets missing\n");
+ ex_print(eptr);
+ return (exNULL);
+ }
+ /* if this table is the only token, parse the table */
+ if (!count &&
+ !((struct ex_ex *) eptr[1].ex_ptr)[1].ex_type) {
+ savex = *((struct ex_ex *) eptr[1].ex_ptr);
+ *((struct ex_ex *) eptr[1].ex_ptr) = nullex;
+ *optr++ = *eptr;
+ lowpre = ex_parse(x, &eptr[2], optr, (long *)0);
+ *((struct ex_ex *) eptr[1].ex_ptr) = savex;
+ return(lowpre);
+ }
+ eptr = (struct ex_ex *) eptr[1].ex_ptr;
+ break;
+ case ET_OP:
+ if (eptr->ex_op == OP_COMMA) {
+ if (!argc || !count || !eptr[1].ex_type) {
+ post("expr: syntax error: illegal comma\n");
+ ex_print(eptr[1].ex_type ? eptr : iptr);
+ return (exNULL);
+ }
+ }
+ if (!eptr[1].ex_type) {
+ post("expr: syntax error: missing operand\n");
+ ex_print(iptr);
+ return (exNULL);
+ }
+ if ((eptr->ex_op & PRE_MASK) <= pre) {
+ pre = eptr->ex_op & PRE_MASK;
+ lowpre = eptr;
+ }
+ break;
+ case ET_FUNC:
+ if (eptr[1].ex_type != ET_LP) {
+ post("expr: ex_parse: no parenthesis\n");
+ return (exNULL);
+ }
+ /* if this function is the only token, parse it */
+ if (!count &&
+ !((struct ex_ex *) eptr[1].ex_ptr)[1].ex_type) {
+ long ac;
+
+ if (eptr[1].ex_ptr == (char *) &eptr[2]) {
+ post("expr: syntax error: missing argument\n");
+ ex_print(eptr);
+ return (exNULL);
+ }
+ ac = 0;
+ savex = *((struct ex_ex *) eptr[1].ex_ptr);
+ *((struct ex_ex *) eptr[1].ex_ptr) = nullex;
+ *optr++ = *eptr;
+ lowpre = ex_parse(x, &eptr[2], optr, &ac);
+ if (!lowpre)
+ return (exNULL);
+ ac++;
+ if (ac !=
+ ((t_ex_func *)eptr->ex_ptr)->f_argc){
+ post("expr: syntax error: function '%s' needs %ld arguments\n",
+ ((t_ex_func *)eptr->ex_ptr)->f_name,
+ ((t_ex_func *)eptr->ex_ptr)->f_argc);
+ return (exNULL);
+ }
+ *((struct ex_ex *) eptr[1].ex_ptr) = savex;
+ return (lowpre);
+ }
+ eptr = (struct ex_ex *) eptr[1].ex_ptr;
+ break;
+ case ET_LP:
+ case ET_LB:
+ if (!count &&
+ !((struct ex_ex *) eptr->ex_ptr)[1].ex_type) {
+ if (eptr->ex_ptr == (char *)(&eptr[1])) {
+ post("expr: syntax error: empty '%s'\n",
+ eptr->ex_type==ET_LP?"()":"[]");
+ ex_print(eptr);
+ return (exNULL);
+ }
+ savex = *((struct ex_ex *) eptr->ex_ptr);
+ *((struct ex_ex *) eptr->ex_ptr) = nullex;
+ lowpre = ex_parse(x, &eptr[1], optr, (long *)0);
+ *((struct ex_ex *) eptr->ex_ptr) = savex;
+ return (lowpre);
+ }
+ eptr = (struct ex_ex *)eptr->ex_ptr;
+ break;
+ case ET_STR:
+ default:
+ ex_print(eptr);
+ post("expr: ex_parse: type = 0x%lx\n", eptr->ex_type);
+ return (exNULL);
+ }
+
+ if (pre == HI_PRE) {
+ post("expr: syntax error: missing operation\n");
+ ex_print(iptr);
+ return (exNULL);
+ }
+ if (count < 2) {
+ post("expr: syntax error: mission operand\n");
+ ex_print(iptr);
+ return (exNULL);
+ }
+ if (count == 2) {
+ if (lowpre != iptr) {
+ post("expr: ex_parse: unary operator should be first\n");
+ return (exNULL);
+ }
+ if (!unary_op(lowpre->ex_op)) {
+ post("expr: syntax error: not a uniary operator\n");
+ ex_print(iptr);
+ return (exNULL);
+ }
+ *optr++ = *lowpre;
+ eptr = ex_parse(x, &lowpre[1], optr, argc);
+ return (eptr);
+ }
+ if (lowpre == iptr) {
+ post("expr: syntax error: mission operand\n");
+ ex_print(iptr);
+ return (exNULL);
+ }
+ savex = *lowpre;
+ *lowpre = nullex;
+ if (savex.ex_op != OP_COMMA)
+ *optr++ = savex;
+ else
+ (*argc)++;
+ eptr = ex_parse(x, iptr, optr, argc);
+ if (eptr) {
+ eptr = ex_parse(x, &lowpre[1], eptr, argc);
+ *lowpre = savex;
+ }
+ return (eptr);
+}
+
+/*
+ * this is the devide zero check for a a non devide operator
+ */
+#define DZC(ARG1,OPR,ARG2) (ARG1 OPR ARG2)
+
+#define EVAL(OPR); \
+eptr = ex_eval(exp, ex_eval(exp, eptr, &left, idx), &right, idx); \
+switch (left.ex_type) { \
+case ET_INT: \
+ switch(right.ex_type) { \
+ case ET_INT: \
+ if (optr->ex_type == ET_VEC) { \
+ op = optr->ex_vec; \
+ scalar = (float)DZC(left.ex_int, OPR, right.ex_int); \
+ for (j = 0; j < exp->exp_vsize; j++) \
+ *op++ = scalar; \
+ } else { \
+ optr->ex_type = ET_INT; \
+ optr->ex_int = DZC(left.ex_int, OPR, right.ex_int); \
+ } \
+ break; \
+ case ET_FLT: \
+ if (optr->ex_type == ET_VEC) { \
+ op = optr->ex_vec; \
+ scalar = DZC(((float)left.ex_int), OPR, right.ex_flt);\
+ for (j = 0; j < exp->exp_vsize; j++) \
+ *op++ = scalar; \
+ } else { \
+ optr->ex_type = ET_FLT; \
+ optr->ex_flt = DZC(((float)left.ex_int), OPR, \
+ right.ex_flt); \
+ } \
+ break; \
+ case ET_VEC: \
+ case ET_VI: \
+ if (optr->ex_type != ET_VEC) { \
+ if (optr->ex_type == ET_VI) { \
+ post("expr~: Int. error %d", __LINE__); \
+ abort(); \
+ } \
+ optr->ex_type = ET_VEC; \
+ optr->ex_vec = (t_float *) \
+ fts_malloc(sizeof (t_float)*exp->exp_vsize); \
+ } \
+ scalar = left.ex_int; \
+ rp = right.ex_vec; \
+ op = optr->ex_vec; \
+ for (i = 0; i < exp->exp_vsize; i++) { \
+ *op++ = DZC (scalar, OPR, *rp); \
+ rp++; \
+ } \
+ break; \
+ case ET_SYM: \
+ default: \
+ post_error((fts_object_t *) exp, \
+ "expr: ex_eval(%d): bad right type %ld\n", \
+ __LINE__, right.ex_type); \
+ nullret = 1; \
+ } \
+ break; \
+case ET_FLT: \
+ switch(right.ex_type) { \
+ case ET_INT: \
+ if (optr->ex_type == ET_VEC) { \
+ op = optr->ex_vec; \
+ scalar = DZC((float) left.ex_flt, OPR, right.ex_int); \
+ for (j = 0; j < exp->exp_vsize; j++) \
+ *op++ = scalar; \
+ } else { \
+ optr->ex_type = ET_FLT; \
+ optr->ex_flt = DZC(left.ex_flt, OPR, right.ex_int); \
+ } \
+ break; \
+ case ET_FLT: \
+ if (optr->ex_type == ET_VEC) { \
+ op = optr->ex_vec; \
+ scalar = DZC(left.ex_flt, OPR, right.ex_flt); \
+ for (j = 0; j < exp->exp_vsize; j++) \
+ *op++ = scalar; \
+ } else { \
+ optr->ex_type = ET_FLT; \
+ optr->ex_flt= DZC(left.ex_flt, OPR, right.ex_flt); \
+ } \
+ break; \
+ case ET_VEC: \
+ case ET_VI: \
+ if (optr->ex_type != ET_VEC) { \
+ if (optr->ex_type == ET_VI) { \
+ post("expr~: Int. error %d", __LINE__); \
+ abort(); \
+ } \
+ optr->ex_type = ET_VEC; \
+ optr->ex_vec = (t_float *) \
+ fts_malloc(sizeof (t_float)*exp->exp_vsize); \
+ } \
+ scalar = left.ex_flt; \
+ rp = right.ex_vec; \
+ op = optr->ex_vec; \
+ for (i = 0; i < exp->exp_vsize; i++) { \
+ *op++ = DZC(scalar, OPR, *rp); \
+ rp++; \
+ } \
+ break; \
+ case ET_SYM: \
+ default: \
+ post_error((fts_object_t *) exp, \
+ "expr: ex_eval(%d): bad right type %ld\n", \
+ __LINE__, right.ex_type); \
+ nullret = 1; \
+ } \
+ break; \
+case ET_VEC: \
+case ET_VI: \
+ if (optr->ex_type != ET_VEC) { \
+ if (optr->ex_type == ET_VI) { \
+ post("expr~: Int. error %d", __LINE__); \
+ abort(); \
+ } \
+ optr->ex_type = ET_VEC; \
+ optr->ex_vec = (t_float *) \
+ fts_malloc(sizeof (t_float)*exp->exp_vsize); \
+ } \
+ op = optr->ex_vec; \
+ lp = left.ex_vec; \
+ switch(right.ex_type) { \
+ case ET_INT: \
+ scalar = right.ex_int; \
+ for (i = 0; i < exp->exp_vsize; i++) { \
+ *op++ = DZC(*lp, OPR, scalar); \
+ lp++; \
+ } \
+ break; \
+ case ET_FLT: \
+ scalar = right.ex_flt; \
+ for (i = 0; i < exp->exp_vsize; i++) { \
+ *op++ = DZC(*lp, OPR, scalar); \
+ lp++; \
+ } \
+ break; \
+ case ET_VEC: \
+ case ET_VI: \
+ rp = right.ex_vec; \
+ for (i = 0; i < exp->exp_vsize; i++) { \
+ /* \
+ * on a RISC processor one could copy \
+ * 8 times in each round to get a considerable \
+ * improvement \
+ */ \
+ *op++ = DZC(*lp, OPR, *rp); \
+ rp++; lp++; \
+ } \
+ break; \
+ case ET_SYM: \
+ default: \
+ post_error((fts_object_t *) exp, \
+ "expr: ex_eval(%d): bad right type %ld\n", \
+ __LINE__, right.ex_type); \
+ nullret = 1; \
+ } \
+ break; \
+case ET_SYM: \
+default: \
+ post_error((fts_object_t *) exp, \
+ "expr: ex_eval(%d): bad left type %ld\n", \
+ __LINE__, left.ex_type); \
+} \
+break;
+
+/*
+ * evaluate a unary operator, TYPE is applied to float operands
+ */
+#define EVAL_UNARY(OPR, TYPE) \
+ eptr = ex_eval(exp, eptr, &left, idx); \
+ switch(left.ex_type) { \
+ case ET_INT: \
+ if (optr->ex_type == ET_VEC) { \
+ ex_mkvector(optr->ex_vec,(float)(OPR left.ex_int),\
+ exp->exp_vsize);\
+ break; \
+ } \
+ optr->ex_type = ET_INT; \
+ optr->ex_int = OPR left.ex_int; \
+ break; \
+ case ET_FLT: \
+ if (optr->ex_type == ET_VEC) { \
+ ex_mkvector(optr->ex_vec, OPR (TYPE left.ex_flt),\
+ exp->exp_vsize);\
+ break; \
+ } \
+ optr->ex_type = ET_FLT; \
+ optr->ex_flt = OPR (TYPE left.ex_flt); \
+ break; \
+ case ET_VI: \
+ case ET_VEC: \
+ j = exp->exp_vsize; \
+ if (optr->ex_type != ET_VEC) { \
+ optr->ex_type = ET_VEC; \
+ optr->ex_vec = (t_float *) \
+ fts_malloc(sizeof (t_float)*exp->exp_vsize); \
+ } \
+ op = optr->ex_vec; \
+ lp = left.ex_vec; \
+ j = exp->exp_vsize; \
+ for (i = 0; i < j; i++) \
+ *op++ = OPR (TYPE *lp++); \
+ break; \
+ default: \
+ post_error((fts_object_t *) exp, \
+ "expr: ex_eval(%d): bad left type %ld\n", \
+ __LINE__, left.ex_type); \
+ nullret++; \
+ } \
+ break;
+
+void
+ex_mkvector(t_float *fp, t_float x, int size)
+{
+ while (size--)
+ *fp++ = x;
+}
+
+/*
+ * ex_dzdetect -- divide by zero detected
+ */
+void
+ex_dzdetect(struct expr *exp)
+{
+ char *etype;
+
+ if (!exp->exp_error & EE_DZ) {
+ if (IS_EXPR(exp))
+ etype = "expr";
+ else if (IS_EXPR_TILDE(exp))
+ etype = "expr~";
+ else if (IS_FEXPR_TILDE(exp))
+ etype = "fexpr~";
+ else {
+ post ("expr -- ex_dzdetect internal error");
+ etype = "";
+ }
+ post ("%s divide by zero detected", etype);
+ exp->exp_error |= EE_DZ;
+ }
+}
+
+
+/*
+ * ex_eval -- evaluate the array of prefix expression
+ * ex_eval returns the pointer to the first unevaluated node
+ * in the array. This is a recursive routine.
+ */
+
+/* SDY
+all the returns in this function need to be changed so that the code
+ends up at the end to check for newly allocated right and left vectors which
+need to be freed
+
+look into the variable nullret
+*/
+struct ex_ex *
+ex_eval(struct expr *exp, struct ex_ex *eptr, struct ex_ex *optr, int idx)
+/* the expr object data pointer */
+/* the operation stack */
+/* the result pointer */
+/* the sample numnber processed for fexpr~ */
+{
+ int i, j;
+ t_float *lp, *rp, *op; /* left, right, and out pointer to vectors */
+ t_float scalar;
+ int nullret = 0; /* did we have an error */
+ struct ex_ex left, right; /* left and right operands */
+
+ left.ex_type = 0;
+ left.ex_int = 0;
+ right.ex_type = 0;
+ right.ex_int = 0;
+
+ if (!eptr)
+ return (exNULL);
+ switch (eptr->ex_type) {
+ case ET_INT:
+ if (optr->ex_type == ET_VEC)
+ ex_mkvector(optr->ex_vec, (float) eptr->ex_int,
+ exp->exp_vsize);
+ else
+ *optr = *eptr;
+ return (++eptr);
+
+ case ET_FLT:
+
+ if (optr->ex_type == ET_VEC)
+ ex_mkvector(optr->ex_vec, eptr->ex_flt, exp->exp_vsize);
+ else
+ *optr = *eptr;
+ return (++eptr);
+
+ case ET_SYM:
+ if (optr->ex_type == ET_VEC) {
+ post_error((fts_object_t *) exp,
+ "expr: ex_eval: cannot turn string to vector\n");
+ return (exNULL);
+ }
+ *optr = *eptr;
+ return (++eptr);
+ case ET_II:
+ if (eptr->ex_int == -1) {
+ post_error((fts_object_t *) exp,
+ "expr: ex_eval: inlet number not set\n");
+ return (exNULL);
+ }
+ if (optr->ex_type == ET_VEC) {
+ ex_mkvector(optr->ex_vec,
+ (t_float)exp->exp_var[eptr->ex_int].ex_int,
+ exp->exp_vsize);
+ } else {
+ optr->ex_type = ET_INT;
+ optr->ex_int = exp->exp_var[eptr->ex_int].ex_int;
+ }
+ return (++eptr);
+ case ET_FI:
+ if (eptr->ex_int == -1) {
+ post_error((fts_object_t *) exp,
+ "expr: ex_eval: inlet number not set\n");
+ return (exNULL);
+ }
+ if (optr->ex_type == ET_VEC) {
+ ex_mkvector(optr->ex_vec,
+ exp->exp_var[eptr->ex_int].ex_flt, exp->exp_vsize);
+ } else {
+ optr->ex_type = ET_FLT;
+ optr->ex_flt = exp->exp_var[eptr->ex_int].ex_flt;
+ }
+ return (++eptr);
+
+ case ET_VSYM:
+ if (optr->ex_type == ET_VEC) {
+ post_error((fts_object_t *) exp,
+ "expr: IntErr. vsym in for vec out\n");
+ return (exNULL);
+ }
+ if (eptr->ex_int == -1) {
+ post_error((fts_object_t *) exp,
+ "expr: ex_eval: inlet number not set\n");
+ return (exNULL);
+ }
+ optr->ex_type = ET_SYM;
+ optr->ex_ptr = exp->exp_var[eptr->ex_int].ex_ptr;
+ return(++eptr);
+
+ case ET_VI:
+ if (optr->ex_type != ET_VEC)
+ *optr = exp->exp_var[eptr->ex_int];
+ else if (optr->ex_vec != exp->exp_var[eptr->ex_int].ex_vec)
+ memcpy(optr->ex_vec, exp->exp_var[eptr->ex_int].ex_vec,
+ exp->exp_vsize * sizeof (t_float));
+ return(++eptr);
+ case ET_VEC:
+ if (optr->ex_type != ET_VEC) {
+ optr->ex_type = ET_VEC;
+ optr->ex_vec = eptr->ex_vec;
+ eptr->ex_type = ET_INT;
+ eptr->ex_int = 0;
+ } else if (optr->ex_vec != eptr->ex_vec) {
+ memcpy(optr->ex_vec, eptr->ex_vec,
+ exp->exp_vsize * sizeof (t_float));
+/* do we need to free here? or can we free higher up */
+/* SDY the next lines do not make sense */
+post("calling fts_free\n");
+abort();
+ fts_free(optr->ex_vec);
+ optr->ex_type = ET_INT;
+ eptr->ex_int = 0;
+ } else { /* this should not happen */
+ post("expr int. error, optr->ex_vec = %d",optr->ex_vec);
+ abort();
+ }
+ return(++eptr);
+ case ET_XI0:
+ /* SDY delete the following check */
+ if (!IS_FEXPR_TILDE(exp) || optr->ex_type==ET_VEC) {
+ post("%d:exp->exp_flags = %d", __LINE__,exp->exp_flags);
+ abort();
+ }
+ optr->ex_type = ET_FLT;
+ optr->ex_flt = exp->exp_var[eptr->ex_int].ex_vec[idx];
+ return(++eptr);
+ case ET_VO:
+ case ET_XI:
+ /* SDY delete the following */
+ if (!IS_FEXPR_TILDE(exp) || optr->ex_type==ET_VEC) {
+ post("%d:exp->exp_flags = %d", __LINE__,exp->exp_flags);
+ abort();
+ }
+ return (eval_sigidx(exp, eptr, optr, idx));
+
+ case ET_TBL:
+ case ET_SI:
+ return (eval_tab(exp, eptr, optr, idx));
+ case ET_FUNC:
+ return (eval_func(exp, eptr, optr, idx));
+ case ET_OP:
+ break;
+ case ET_STR:
+ case ET_LP:
+ case ET_LB:
+ default:
+ post_error((fts_object_t *) exp,
+ "expr: ex_eval: unexpected type %d\n", eptr->ex_type);
+ return (exNULL);
+ }
+ if (!eptr[1].ex_type) {
+ post_error((fts_object_t *) exp,
+ "expr: ex_eval: not enough nodes 1\n");
+ return (exNULL);
+ }
+ if (!unary_op(eptr->ex_op) && !eptr[2].ex_type) {
+ post_error((fts_object_t *) exp,
+ "expr: ex_eval: not enough nodes 2\n");
+ return (exNULL);
+ }
+
+ switch((eptr++)->ex_op) {
+ case OP_NOT:
+ EVAL_UNARY(!, +);
+ case OP_NEG:
+ EVAL_UNARY(~, (long));
+ case OP_UMINUS:
+ EVAL_UNARY(-, +);
+ case OP_MUL:
+ EVAL(*);
+ case OP_ADD:
+ EVAL(+);
+ case OP_SUB:
+ EVAL(-);
+ case OP_LT:
+ EVAL(<);
+ case OP_LE:
+ EVAL(<=);
+ case OP_GT:
+ EVAL(>);
+ case OP_GE:
+ EVAL(>=);
+ case OP_EQ:
+ EVAL(==);
+ case OP_NE:
+ EVAL(!=);
+/*
+ * following operators convert their argument to integer
+ */
+#undef DZC
+#define DZC(ARG1,OPR,ARG2) (((int)ARG1) OPR ((int)ARG2))
+ case OP_SL:
+ EVAL(<<);
+ case OP_SR:
+ EVAL(>>);
+ case OP_AND:
+ EVAL(&);
+ case OP_XOR:
+ EVAL(^);
+ case OP_OR:
+ EVAL(|);
+ case OP_LAND:
+ EVAL(&&);
+ case OP_LOR:
+ EVAL(||);
+/*
+ * for modulo we need to convert to integer and check for divide by zero
+ */
+#undef DZC
+#define DZC(ARG1,OPR,ARG2) (((ARG2)?(((int)ARG1) OPR ((int)ARG2)) \
+ : (ex_dzdetect(exp),0)))
+ case OP_MOD:
+ EVAL(%);
+/*
+ * define the divide by zero check for divide
+ */
+#undef DZC
+#define DZC(ARG1,OPR,ARG2) (((ARG2)?(ARG1 OPR ARG2):(ex_dzdetect(exp),0)))
+ case OP_DIV:
+ EVAL(/);
+ case OP_LP:
+ case OP_RP:
+ case OP_LB:
+ case OP_RB:
+ case OP_COMMA:
+ case OP_SEMI:
+ default:
+ post_error((fts_object_t *) exp, "expr: ex_print: bad op 0x%x\n", eptr->ex_op);
+ return (exNULL);
+ }
+
+
+/* SDY
+all the returns in the function need to be changed to come here
+to make sure that we are freeing any allocated buffer pointed to
+by left and right vectors
+*/
+
+ /*
+ * the left and right nodes could have been transformed to vectors
+ * down the chain
+ */
+ if (left.ex_type == ET_VEC)
+ fts_free(left.ex_vec);
+ if (right.ex_type == ET_VEC)
+ fts_free(right.ex_vec);
+ if (nullret)
+ return (exNULL);
+ else
+ return (eptr);
+}
+
+/*
+ * eval_func -- evaluate a function, call ex_eval() on all the arguments
+ * so that all of them are terminal nodes. The call the
+ * appropriate function
+ */
+struct ex_ex *
+eval_func(struct expr *exp, struct ex_ex *eptr, struct ex_ex *optr, int idx)
+/* the expr object data pointer */
+/* the operation stack */
+/* the result pointer */
+{
+ int i;
+ struct ex_ex args[MAX_ARGS];
+ t_ex_func *f;
+
+ f = (t_ex_func *)(eptr++)->ex_ptr;
+ if (!f || !f->f_name) {
+ return (exNULL);
+ }
+ if (f->f_argc > MAX_ARGS) {
+ post_error((fts_object_t *) exp, "expr: eval_func: asking too many arguments\n");
+ return (exNULL);
+ }
+
+ for (i = 0; i < f->f_argc; i++) {
+ args[i].ex_type = 0;
+ args[i].ex_int = 0;
+ eptr = ex_eval(exp, eptr, &args[i], idx);
+ }
+ (*f->f_func)(exp, f->f_argc, args, optr);
+ for (i = 0; i < f->f_argc; i++) {
+ if (args[i].ex_type == ET_VEC)
+ fts_free(args[i].ex_vec);
+ }
+ return (eptr);
+}
+
+/*
+ * eval_tab --
+ */
+struct ex_ex *
+eval_tab(struct expr *exp, struct ex_ex *eptr, struct ex_ex *optr, int idx)
+/* the expr object data pointer */
+/* the operation stack */
+/* the result pointer */
+{
+ struct ex_ex arg;
+ char *tbl = (char *) 0;
+ int notable = 0;
+
+ if (eptr->ex_type == ET_SI) {
+ if (!exp->exp_var[eptr->ex_int].ex_ptr) {
+/* SDY post_error() does not work in MAX/MSP yet
+ post_error((fts_object_t *) exp,
+ "expr: syntax error: no string for inlet %d\n", eptr->ex_int + 1);
+*/
+ if (!(exp->exp_error & EE_NOTABLE)) {
+ post("expr: syntax error: no string for inlet %d", eptr->ex_int + 1);
+ post("expr: No more table errors will be reported");
+ post("expr: till the next reset");
+ exp->exp_error |= EE_NOTABLE;
+ }
+ notable++;
+ } else
+ tbl = (char *) exp->exp_var[eptr->ex_int].ex_ptr;
+ } else if (eptr->ex_type == ET_TBL)
+ tbl = (char *) eptr->ex_ptr;
+ else {
+ post_error((fts_object_t *) exp, "expr: eval_tbl: bad type %ld\n", eptr->ex_type);
+ notable++;
+
+ }
+ arg.ex_type = 0;
+ arg.ex_int = 0;
+ eptr = ex_eval(exp, ++eptr, &arg, idx);
+
+ optr->ex_type = ET_INT;
+ optr->ex_int = 0;
+ if (!notable)
+ (void)max_ex_tab(exp, (t_symbol *)tbl, &arg, optr);
+ return (eptr);
+}
+
+/*
+ * eval_sigidx -- evaluate the value of an indexed signal for fexpr~
+ */
+struct ex_ex *
+eval_sigidx(struct expr *exp, struct ex_ex *eptr, struct ex_ex *optr, int idx)
+/* the expr object data pointer */
+/* the operation stack */
+/* the result pointer */
+/* the index */
+{
+ struct ex_ex arg;
+ struct ex_ex *reteptr;
+ int i = 0, j = 0;
+ float fi = 0, /* index in float */
+ rem_i = 0; /* remains of the float */
+ char *tbl;
+
+ arg.ex_type = 0;
+ arg.ex_int = 0;
+ reteptr = ex_eval(exp, eptr + 1, &arg, idx);
+ if (arg.ex_type == ET_FLT) {
+ fi = arg.ex_flt; /* float index */
+ i = (int) arg.ex_flt; /* integer index */
+ rem_i = arg.ex_flt - i; /* remains of integer */
+ } else if (arg.ex_type == ET_INT) {
+ fi = arg.ex_int; /* float index */
+ i = arg.ex_int;
+ rem_i = 0;
+ } else {
+ post("eval_sigidx: bad res type (%d)", arg.ex_type);
+ }
+ optr->ex_type = ET_FLT;
+ /*
+ * indexing an input vector
+ */
+ if (eptr->ex_type == ET_XI) {
+ if (fi > 0) {
+ if (!(exp->exp_error & EE_BI_INPUT)) {
+ exp->exp_error |= EE_BI_INPUT;
+ post("expr: input vector index > 0, (vector x%d[%f])",
+ eptr->ex_int + 1, i + rem_i);
+ post("fexpr~: index assumed to be = 0");
+ post("fexpr~: no error report till next reset");
+ ex_print(eptr);
+ }
+ /* just replace it with zero */
+ i = 0;
+ rem_i = 0;
+ }
+ if (cal_sigidx(optr, i, rem_i, idx, exp->exp_vsize,
+ exp->exp_var[eptr->ex_int].ex_vec,
+ exp->exp_p_var[eptr->ex_int])) {
+ if (!(exp->exp_error & EE_BI_INPUT)) {
+ exp->exp_error |= EE_BI_INPUT;
+ post("expr: input vector index < -VectorSize, (vector x%d[%f])", eptr->ex_int + 1, fi);
+ ex_print(eptr);
+ post("fexpr~: index assumed to be = -%d",
+ exp->exp_vsize);
+ post("fexpr~: no error report till next reset");
+ }
+ }
+
+ /*
+ * indexing an output vector
+ */
+ } else if (eptr->ex_type == ET_VO) {
+ /* for output vectors index of zero is not legal */
+ if (fi >= 0) {
+ if (!(exp->exp_error & EE_BI_OUTPUT)) {
+ exp->exp_error |= EE_BI_OUTPUT;
+ post("fexpr~: bad output index, (%f)", fi);
+ ex_print(eptr);
+ post("fexpr~: no error report till next reset");
+ post("fexpr~: index assumed to be = -1");
+ }
+ i = 0;
+ }
+ if (cal_sigidx(optr, i, rem_i, idx, exp->exp_vsize,
+ exp->exp_tmpres, exp->exp_p_res)) {
+ if (!(exp->exp_error & EE_BI_OUTPUT)) {
+ exp->exp_error |= EE_BI_OUTPUT;
+ post("fexpr~: bad output index, (%f)", fi);
+ ex_print(eptr);
+ post("fexpr~: index assumed to be = -%d",
+ exp->exp_vsize);
+ }
+ }
+ } else {
+ optr->ex_flt = 0;
+ post("fexpr~:eval_sigidx: internal error - unknown vector (%d)",
+ eptr->ex_type);
+ }
+ return (reteptr);
+}
+
+/*
+ * cal_sigidx -- given two tables (one current one previous) calculate an
+ * evaluation of a float index into the vectors by linear
+ * interpolation
+ * return 0 on success, 1 on failure (index out of bound)
+ */
+static int
+cal_sigidx(struct ex_ex *optr, /* The output value */
+ int i, float rem_i, /* integer and fractinal part of index */
+ int idx, /* index of current fexpr~ processing */
+ int vsize, /* vector size */
+ float *curvec, float *prevec) /* current and previous table */
+{
+ int n;
+
+ n = i + idx;
+ if (n > 0) {
+ /* from the curvec */
+ if (rem_i)
+ optr->ex_flt = curvec[n] +
+ rem_i * (curvec[n] - curvec[n - 1]);
+ else
+ optr->ex_flt = curvec[n];
+ return (0);
+ }
+ if (n == 0) {
+ /*
+ * this is the case that the remaining float
+ * is between two tables
+ */
+ if (rem_i)
+ optr->ex_flt = *curvec +
+ rem_i * (*curvec - prevec[vsize - 1]);
+ else
+ optr->ex_flt = *curvec;
+ return (0);
+ }
+ /* find the index in the saved buffer */
+ n = vsize + n;
+ if (n > 0) {
+ if (rem_i)
+ optr->ex_flt = prevec[n] +
+ rem_i * (prevec[n] - prevec[n - 1]);
+ else
+ optr->ex_flt = prevec[n];
+ return (0);
+ }
+ /* out of bound */
+ optr->ex_flt = *prevec;
+ return (1);
+}
+
+static char *exp_str;
+/*
+ * set_tokens -- set a new string for reading tokens
+ */
+
+void
+set_tokens(char *s)
+{
+ exp_str = s;
+}
+/*
+ * getoken -- return 1 on syntax error otherwise 0
+ */
+int
+getoken(struct expr *exp, struct ex_ex *eptr)
+{
+ char *p;
+ long i;
+
+ if (!exp_str) {
+ post("expr: getoken: expression string not set\n");
+ return (0);
+ }
+retry:
+ if (!*exp_str) {
+ eptr->ex_type = 0;
+ eptr->ex_int = 0;
+ return (0);
+ }
+ eptr->ex_type = ET_OP;
+ switch (*exp_str++) {
+ case '\\':
+ case ' ':
+ case '\t':
+ goto retry;
+ case ';':
+ post("expr: syntax error: ';' not implemented\n");
+ return (1);
+ case ',':
+ eptr->ex_op = OP_COMMA;
+ break;
+ case '(':
+ eptr->ex_op = OP_LP;
+ break;
+ case ')':
+ eptr->ex_op = OP_RP;
+ break;
+ case ']':
+ eptr->ex_op = OP_RB;
+ break;
+ case '~':
+ eptr->ex_op = OP_NEG;
+ break;
+ /* we will take care of unary minus later */
+ case '*':
+ eptr->ex_op = OP_MUL;
+ break;
+ case '/':
+ eptr->ex_op = OP_DIV;
+ break;
+ case '%':
+ eptr->ex_op = OP_MOD;
+ break;
+ case '+':
+ eptr->ex_op = OP_ADD;
+ break;
+ case '-':
+ eptr->ex_op = OP_SUB;
+ break;
+ case '^':
+ eptr->ex_op = OP_XOR;
+ break;
+ case '[':
+ eptr->ex_op = OP_LB;
+ break;
+ case '!':
+ if (*exp_str == '=') {
+ eptr->ex_op = OP_NE;
+ exp_str++;
+ } else
+ eptr->ex_op = OP_NOT;
+ break;
+ case '<':
+ switch (*exp_str) {
+ case '<':
+ eptr->ex_op = OP_SL;
+ exp_str++;
+ break;
+ case '=':
+ eptr->ex_op = OP_LE;
+ exp_str++;
+ break;
+ default:
+ eptr->ex_op = OP_LT;
+ break;
+ }
+ break;
+ case '>':
+ switch (*exp_str) {
+ case '>':
+ eptr->ex_op = OP_SR;
+ exp_str++;
+ break;
+ case '=':
+ eptr->ex_op = OP_GE;
+ exp_str++;
+ break;
+ default:
+ eptr->ex_op = OP_GT;
+ break;
+ }
+ break;
+ case '=':
+ if (*exp_str++ != '=') {
+ post("expr: syntax error: =\n");
+ return (1);
+ }
+ eptr->ex_op = OP_EQ;
+ break;
+
+ case '&':
+ if (*exp_str == '&') {
+ exp_str++;
+ eptr->ex_op = OP_LAND;
+ } else
+ eptr->ex_op = OP_AND;
+ break;
+
+ case '|':
+ if ((*exp_str == '|')) {
+ exp_str++;
+ eptr->ex_op = OP_LOR;
+ } else
+ eptr->ex_op = OP_OR;
+ break;
+ case '$':
+ switch (*exp_str++) {
+ case 'I':
+ case 'i':
+ eptr->ex_type = ET_II;
+ break;
+ case 'F':
+ case 'f':
+ eptr->ex_type = ET_FI;
+ break;
+ case 'S':
+ case 's':
+ eptr->ex_type = ET_SI;
+ break;
+ case 'V':
+ case 'v':
+ if (IS_EXPR_TILDE(exp)) {
+ eptr->ex_type = ET_VI;
+ break;
+ }
+ post("$v? works only for expr~");
+ post("expr: syntax error: %s\n", &exp_str[-2]);
+ return (1);
+ case 'X':
+ case 'x':
+ if (IS_FEXPR_TILDE(exp)) {
+ eptr->ex_type = ET_XI;
+ break;
+ }
+ post("$x? works only for fexpr~");
+ post("expr: syntax error: %s\n", &exp_str[-2]);
+ return (1);
+ case 'y':
+ case 'Y':
+ if (IS_FEXPR_TILDE(exp)) {
+ eptr->ex_type = ET_VO;
+ /*$y takes no number */
+ goto noinletnum;
+ }
+ post("$y works only for fexpr~");
+ default:
+ post("expr: syntax error: %s\n", &exp_str[-2]);
+ return (1);
+ }
+ p = atoif(exp_str, &eptr->ex_op, &i);
+ if (!p) {
+ post("expr: syntax error: %s\n", &exp_str[-2]);
+ return (1);
+ }
+ if (i != ET_INT) {
+ post("expr: syntax error: %s\n", exp_str);
+ return (1);
+ }
+ /*
+ * make the user inlets one based rather than zero based
+ * therefore we decrement the number that user has supplied
+ */
+ if (!eptr->ex_op || (eptr->ex_op)-- > MAX_VARS) {
+ post("expr: syntax error: inlet out of range: %s\n",
+ exp_str);
+ return (1);
+ }
+
+/*
+ * until we can change the input type of inlets on the fly (at pd_new()
+ * time) the first input to expr~ is always a vectore and $f1 or $i1 is
+ * illegal for fexr~
+ */
+if (eptr->ex_op == 0 &&
+ (IS_FEXPR_TILDE(exp) || IS_EXPR_TILDE(exp)) &&
+ (eptr->ex_type==ET_II || eptr->ex_type==ET_FI || eptr->ex_type==ET_SI)) {
+ post("first inlet of expr~ for fexpr~ can only be a vector");
+ return (1);
+}
+ /* record the inlet type and check for consistency */
+ if (!exp->exp_var[eptr->ex_op].ex_type)
+ exp->exp_var[eptr->ex_op].ex_type = eptr->ex_type;
+ else if (exp->exp_var[eptr->ex_op].ex_type != eptr->ex_type) {
+ post("expr: syntax error: inlets can only have one type: %s\n", exp_str);
+ return (1);
+ }
+ exp_str = p;
+noinletnum:
+ break;
+ case '"':
+ {
+ struct ex_ex ex;
+
+ p = exp_str;
+ if (!*exp_str || *exp_str == '"') {
+ post("expr: syntax error: empty symbol: %s\n", --exp_str);
+ return (1);
+ }
+ if (getoken(exp, &ex))
+ return (1);
+ switch (ex.ex_type) {
+ case ET_STR:
+ if (ex_getsym(ex.ex_ptr, (t_symbol **)&(eptr->ex_ptr))) {
+ post("expr: syntax error: getoken: problms with ex_getsym\n");
+ return (1);
+ }
+ eptr->ex_type = ET_SYM;
+ break;
+ case ET_SI:
+ *eptr = ex;
+ eptr->ex_type = ET_VSYM;
+ break;
+ default:
+ post("expr: syntax error: bad symbol name: %s\n", p);
+ return (1);
+ }
+ if (*exp_str++ != '"') {
+ post("expr: syntax error: missing '\"'\n");
+ return (1);
+ }
+ break;
+ }
+ case '.':
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ p = atoif(--exp_str, &eptr->ex_int, &eptr->ex_type);
+ if (!p)
+ return (1);
+ exp_str = p;
+ break;
+
+ default:
+ /*
+ * has to be a string, it should either be a
+ * function or a table
+ */
+ p = --exp_str;
+ for (i = 0; name_ok(*p); i++)
+ p++;
+ if (!i) {
+ post("expr: syntax error: %s\n", exp_str);
+ return (1);
+ }
+ eptr->ex_ptr = (char *)fts_malloc(i + 1);
+ strncpy(eptr->ex_ptr, exp_str, (int) i);
+ (eptr->ex_ptr)[i] = 0;
+ exp_str = p;
+ /*
+ * we mark this as a string and later we will change this
+ * to either a function or a table
+ */
+ eptr->ex_type = ET_STR;
+ break;
+ }
+ return (0);
+}
+
+/*
+ * atoif -- ascii to float or integer (understands hex numbers also)
+ */
+char *
+atoif(char *s, long int *value, long int *type)
+{
+ char *p;
+ long int_val = 0;
+ int flt = 0;
+ float pos = 0;
+ float flt_val = 0;
+ int base = 10;
+
+ p = s;
+ if (*p == '0' && (p[1] == 'x' || p[1] == 'X')) {
+ base = 16;
+ p += 2;
+ }
+ while (8) {
+ switch (*p) {
+ case '.':
+ if (flt || base != 10) {
+ post("expr: syntax error: %s\n", s);
+ return ((char *) 0);
+ }
+ flt++;
+ pos = 10;
+ flt_val = int_val;
+ break;
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ if (flt) {
+ flt_val += (*p - '0') / pos;
+ pos *= 10;
+ } else {
+ int_val *= base;
+ int_val += (*p - '0');
+ }
+ break;
+ case 'a':
+ case 'b':
+ case 'c':
+ case 'd':
+ case 'e':
+ case 'f':
+ if (base != 16 || flt) {
+ post("expr: syntax error: %s\n", s);
+ return ((char *) 0);
+ }
+ int_val *= base;
+ int_val += (*p - 'a' + 10);
+ break;
+ case 'A':
+ case 'B':
+ case 'C':
+ case 'D':
+ case 'E':
+ case 'F':
+ if (base != 16 || flt) {
+ post("expr: syntax error: %s\n", s);
+ return ((char *) 0);
+ }
+ int_val *= base;
+ int_val += (*p - 'A' + 10);
+ break;
+ default:
+ if (flt) {
+ *type = ET_FLT;
+ *((float *) value) = flt_val;
+ } else {
+ *type = ET_INT;
+ *value = int_val;
+ }
+ return (p);
+ }
+ p++;
+ }
+}
+
+/*
+ * find_func -- returns a pointer to the found function structure
+ * otherwise it returns 0
+ */
+t_ex_func *
+find_func(char *s)
+{
+ t_ex_func *f;
+
+ for (f = ex_funcs; f->f_name; f++)
+ if (!strcmp(f->f_name, s))
+ return (f);
+ return ((t_ex_func *) 0);
+}
+
+
+/*
+ * ex_print -- print an expression array
+ */
+
+void
+ex_print(struct ex_ex *eptr)
+{
+
+ while (eptr->ex_type) {
+ switch (eptr->ex_type) {
+ case ET_INT:
+ post("%ld ", eptr->ex_int);
+ break;
+ case ET_FLT:
+ post("%f ", eptr->ex_flt);
+ break;
+ case ET_STR:
+ post("%s ", eptr->ex_ptr);
+ break;
+ case ET_TBL:
+ post("%s ", ex_symname((fts_symbol_t )eptr->ex_ptr));
+ break;
+ case ET_SYM:
+ post("\"%s\" ", ex_symname((fts_symbol_t )eptr->ex_ptr));
+ break;
+ case ET_VSYM:
+ post("\"$s%ld\" ", eptr->ex_int + 1);
+ break;
+ case ET_FUNC:
+ post("%s ",
+ ((t_ex_func *)eptr->ex_ptr)->f_name);
+ break;
+ case ET_LP:
+ post("%c", '(');
+ break;
+ /* CHANGE
+ case ET_RP:
+ post("%c ", ')');
+ break;
+ */
+ case ET_LB:
+ post("%c", '[');
+ break;
+ /* CHANGE
+ case ET_RB:
+ post("%c ", ']');
+ break;
+ */
+ case ET_II:
+ post("$i%ld ", eptr->ex_int + 1);
+ break;
+ case ET_FI:
+ post("$f%ld ", eptr->ex_int + 1);
+ break;
+ case ET_SI:
+ post("$s%lx ", eptr->ex_ptr);
+ break;
+ case ET_VI:
+ post("$v%lx ", eptr->ex_vec);
+ break;
+ case ET_VEC:
+ post("vec = %ld ", eptr->ex_vec);
+ break;
+ case ET_VO:
+ post("$y");
+ break;
+ case ET_XI:
+ case ET_XI0:
+ post("$x%d", eptr->ex_int + 1);
+ break;
+ case ET_OP:
+ switch (eptr->ex_op) {
+ case OP_LP:
+ post("%c", '(');
+ break;
+ case OP_RP:
+ post("%c ", ')');
+ break;
+ case OP_LB:
+ post("%c", '[');
+ break;
+ case OP_RB:
+ post("%c ", ']');
+ break;
+ case OP_NOT:
+ post("%c", '!');
+ break;
+ case OP_NEG:
+ post("%c", '~');
+ break;
+ case OP_UMINUS:
+ post("%c", '-');
+ break;
+ case OP_MUL:
+ post("%c", '*');
+ break;
+ case OP_DIV:
+ post("%c", '/');
+ break;
+ case OP_MOD:
+ post("%c", '%');
+ break;
+ case OP_ADD:
+ post("%c", '+');
+ break;
+ case OP_SUB:
+ post("%c", '-');
+ break;
+ case OP_SL:
+ post("%s", "<<");
+ break;
+ case OP_SR:
+ post("%s", ">>");
+ break;
+ case OP_LT:
+ post("%c", '<');
+ break;
+ case OP_LE:
+ post("%s", "<=");
+ break;
+ case OP_GT:
+ post("%c", '>');
+ break;
+ case OP_GE:
+ post("%s", ">=");
+ break;
+ case OP_EQ:
+ post("%s", "==");
+ break;
+ case OP_NE:
+ post("%s", "!=");
+ break;
+ case OP_AND:
+ post("%c", '&');
+ break;
+ case OP_XOR:
+ post("%c", '^');
+ break;
+ case OP_OR:
+ post("%c", '|');
+ break;
+ case OP_LAND:
+ post("%s", "&&");
+ break;
+ case OP_LOR:
+ post("%s", "||");
+ break;
+ case OP_COMMA:
+ post("%c", ',');
+ break;
+ case OP_SEMI:
+ post("%c", ';');
+ break;
+ default:
+ post("expr: ex_print: bad op 0x%lx\n", eptr->ex_op);
+ }
+ break;
+ default:
+ post("expr: ex_print: bad type 0x%lx\n", eptr->ex_type);
+ }
+ eptr++;
+ }
+ post("\n");
+}
+
+#ifdef NT
+void ABORT( void) {bug("expr");}
+#endif
diff --git a/pd/extra/expr~/vexp.h b/pd/extra/expr~/vexp.h
new file mode 100644
index 00000000..dd93d2b8
--- /dev/null
+++ b/pd/extra/expr~/vexp.h
@@ -0,0 +1,233 @@
+/*
+ * jMax
+ * Copyright (C) 1994, 1995, 1998, 1999 by IRCAM-Centre Georges Pompidou, Paris, France.
+ *
+ * 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.
+ *
+ * See file LICENSE for further informations on licensing terms.
+ *
+ * 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.
+ *
+ * Based on Max/ISPW by Miller Puckette.
+ *
+ * Authors: Maurizio De Cecco, Francois Dechelle, Enzo Maggi, Norbert Schnell.
+ *
+ */
+
+/* "expr" was written by Shahrokh Yadegari c. 1989. -msp */
+/* "expr~" and "fexpr~" conversion by Shahrokh Yadegari c. 1999,2000 */
+
+#define MSP
+#ifdef PD
+#undef MSP
+#endif
+
+#ifdef PD
+#include "m_pd.h"
+#else /* MSP */
+#include "ext.h"
+#include "z_dsp.h"
+#endif
+
+#include "fts_to_pd.h"
+/* This is put in fts_to_pd.h
+
+#ifdef MSP
+#define t_atom Atom
+#define t_symbol Symbol
+#define pd_new(x) newobject(x);
+#define t_outlet void
+#endif
+*/
+
+/*
+ * Currently the maximum number of variables (inlets) that are supported
+ * is 10.
+ */
+
+#define MAX_VARS 9
+#define MINODES 10 /* was 200 */
+
+/* terminal defines */
+
+/*
+ * operations
+ * (x<<16|y) x defines the level of precedence,
+ * the lower the number the lower the precedence
+ * separators are defines as operators just for convenience
+ */
+
+#define OP_SEMI ((long)(1<<16|1)) /* ; */
+#define OP_COMMA ((long)(2<<16|2)) /* , */
+#define OP_LOR ((long)(3<<16|3)) /* || */
+#define OP_LAND ((long)(4<<16|4)) /* && */
+#define OP_OR ((long)(5<<16|5)) /* | */
+#define OP_XOR ((long)(6<<16|6)) /* ^ */
+#define OP_AND ((long)(7<<16|7)) /* & */
+#define OP_NE ((long)(8<<16|8)) /* != */
+#define OP_EQ ((long)(8<<16|9)) /* == */
+#define OP_GE ((long)(9<<16|10)) /* >= */
+#define OP_GT ((long)(9<<16|11)) /* > */
+#define OP_LE ((long)(9<<16|12)) /* <= */
+#define OP_LT ((long)(9<<16|13)) /* < */
+#define OP_SR ((long)(10<<16|14)) /* >> */
+#define OP_SL ((long)(10<<16|15)) /* << */
+#define OP_SUB ((long)(11<<16|16)) /* - */
+#define OP_ADD ((long)(11<<16|17)) /* + */
+#define OP_MOD ((long)(12<<16|18)) /* % */
+#define OP_DIV ((long)(12<<16|19)) /* / */
+#define OP_MUL ((long)(12<<16|20)) /* * */
+#define OP_UMINUS ((long)(13<<16|21)) /* - unary minus */
+#define OP_NEG ((long)(13<<16|22)) /* ~ one complement */
+#define OP_NOT ((long)(13<<16|23)) /* ! */
+#define OP_RB ((long)(14<<16|24)) /* ] */
+#define OP_LB ((long)(14<<16|25)) /* [ */
+#define OP_RP ((long)(14<<16|26)) /* ) */
+#define OP_LP ((long)(14<<16|27)) /* ( */
+#define HI_PRE ((long)(100<<16)) /* infinite precedence */
+#define PRE_MASK ((long)0xffff0000) /* precedence level mask */
+
+struct ex_ex;
+
+#define name_ok(c) (((c)=='_') || ((c)>='a' && (c)<='z') || \
+ ((c)>='A' && (c)<='Z') || ((c) >= '0' && (c) <= '9'))
+#define unary_op(x) ((x) == OP_NOT || (x) == OP_NEG || (x) == OP_UMINUS)
+
+struct ex_ex {
+ union {
+ long v_int;
+ float v_flt;
+ t_float *v_vec; /* this is an for allocated vector */
+ long op;
+ char *ptr;
+ } ex_cont; /* content */
+#define ex_int ex_cont.v_int
+#define ex_flt ex_cont.v_flt
+#define ex_vec ex_cont.v_vec
+#define ex_op ex_cont.op
+#define ex_ptr ex_cont.ptr
+ long ex_type; /* type of the node */
+};
+#define exNULL ((struct ex_ex *)0)
+
+/* defines for ex_type */
+#define ET_INT 0x1 /* an int */
+#define ET_FLT 0x2 /* a float */
+#define ET_OP 0x3 /* operator */
+#define ET_STR 0x4 /* string */
+#define ET_TBL 0x5 /* a table, the content is a pointer */
+#define ET_FUNC 0x6 /* a function */
+#define ET_SYM 0x7 /* symbol ("string") */
+#define ET_VSYM 0x8 /* variable symbol ("$s?") */
+ /* we treat parenthesis and brackets */
+ /* special to keep a pointer to their */
+ /* match in the content */
+#define ET_LP 0x9 /* left parenthesis */
+#define ET_LB 0x10 /* left bracket */
+#define ET_II 0x11 /* and integer inlet */
+#define ET_FI 0x12 /* float inlet */
+#define ET_SI 0x13 /* string inlet */
+#define ET_VI 0x14 /* signal inlet */
+#define ET_VEC 0x15 /* allocated signal vector */
+ /* special types for fexpr~ */
+#define ET_VO 0x16 /* vector output for fexpr~ */
+#define ET_XI 0x17 /* vector input for fexpr~ */
+#define ET_XI0 0x18 /* shorthand for $x?[0] */
+
+/* defines for ex_flags */
+#define EF_TYPE_MASK 0x07 /* first three bits define the type of expr */
+#define EF_EXPR 0x01 /* expr - control in and out */
+#define EF_EXPR_TILDE 0x02 /* expr~ signal and control in, signal out */
+#define EF_FEXPR_TILDE 0x04 /* fexpr~ filter expression */
+
+#define EF_STOP 0x08 /* is it stopped used for expr~ and fexpr~ */
+
+#define IS_EXPR(x) ((((x)->exp_flags&EF_TYPE_MASK)|EF_EXPR) == EF_EXPR)
+#define IS_EXPR_TILDE(x) \
+ ((((x)->exp_flags&EF_TYPE_MASK)|EF_EXPR_TILDE)==EF_EXPR_TILDE)
+#define IS_FEXPR_TILDE(x) \
+ ((((x)->exp_flags&EF_TYPE_MASK)|EF_FEXPR_TILDE)==EF_FEXPR_TILDE)
+
+#define SET_EXPR(x) (x)->exp_flags |= EF_EXPR; \
+ (x)->exp_flags &= ~EF_EXPR_TILDE; \
+ (x)->exp_flags &= ~EF_FEXPR_TILDE;
+
+#define SET_EXPR_TILDE(x) (x)->exp_flags &= ~EF_EXPR; \
+ (x)->exp_flags |= EF_EXPR_TILDE; \
+ (x)->exp_flags &= ~EF_FEXPR_TILDE;
+
+#define SET_FEXPR_TILDE(x) (x)->exp_flags &= ~EF_EXPR; \
+ (x)->exp_flags &= ~EF_EXPR_TILDE; \
+ (x)->exp_flags |= EF_FEXPR_TILDE;
+
+/*
+ * defines for expr_error
+ */
+#define EE_DZ 0x01 /* divide by zero error */
+#define EE_BI_OUTPUT 0x02 /* Bad output index */
+#define EE_BI_INPUT 0x04 /* Bad input index */
+#define EE_NOTABLE 0x08 /* NO TABLE */
+
+typedef struct expr {
+#ifdef PD
+ t_object exp_ob;
+#else /* MSP */
+ t_pxobject exp_ob;
+#endif
+ int exp_flags; /* are we expr~, fexpr~, or expr */
+ int exp_error; /* reported errors */
+ t_outlet *exp_outlet;
+#ifdef PD
+ struct _exprproxy *exp_proxy;
+#else /* MAX */
+ void *exp_proxy[MAX_VARS];
+ long exp_proxy_id;
+#endif
+ struct ex_ex *exp_stack;
+ struct ex_ex exp_var[MAX_VARS];
+ struct ex_ex exp_res; /* the evluation result */
+ t_float *exp_p_var[MAX_VARS];
+ t_float *exp_p_res; /* the previous evaluation result */
+ t_float *exp_tmpres; /* temporty result for fexpr~ */
+ int exp_vsize; /* the size of the signal vector */
+ int exp_nivec; /* # of vector inlets */
+ float exp_f; /* control value to be transformed to signal */
+} t_expr;
+
+typedef struct ex_funcs {
+ char *f_name; /* function name */
+ void (*f_func)(t_expr *, long, struct ex_ex *, struct ex_ex *);
+ /* the real function performing the function (void, no return!!!) */
+ long f_argc; /* number of arguments */
+} t_ex_func;
+
+/* function prototypes for pd-related functions called withing vexp.h */
+
+extern int max_ex_tab(struct expr *expr, t_symbol *s, struct ex_ex *arg, struct ex_ex *optr);
+extern int ex_getsym(char *p, t_symbol **s);
+extern const char *ex_symname(t_symbol *s);
+void ex_mkvector(t_float *fp, t_float x, int size);
+extern void ex_size(t_expr *expr, long int argc, struct ex_ex *argv,
+ struct ex_ex *optr);
+extern void ex_sum(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr);
+extern void ex_Sum(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr);
+extern void ex_avg(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr);
+extern void ex_Avg(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr);
+extern void ex_store(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr);
+
+#ifdef NT
+#pragma warning (disable: 4305 4244)
+
+#define abort ABORT
+void ABORT(void);
+#endif
diff --git a/pd/extra/expr~/vexp_fun.c b/pd/extra/expr~/vexp_fun.c
new file mode 100644
index 00000000..2879d96b
--- /dev/null
+++ b/pd/extra/expr~/vexp_fun.c
@@ -0,0 +1,828 @@
+/*
+ * jMax
+ * Copyright (C) 1994, 1995, 1998, 1999 by IRCAM-Centre Georges Pompidou, Paris, France.
+ *
+ * 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.
+ *
+ * See file LICENSE for further informations on licensing terms.
+ *
+ * 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.
+ *
+ * Based on Max/ISPW by Miller Puckette.
+ *
+ * Authors: Maurizio De Cecco, Francois Dechelle, Enzo Maggi, Norbert Schnell.
+ *
+ */
+
+/* "expr" was written by Shahrokh Yadegari c. 1989. -msp */
+/* Nov. 2001 - conversion for expr~ --sdy */
+
+/*
+ * vexp_func.c -- this file include all the functions for vexp.
+ * the first two arguments to the function are the number
+ * of argument and an array of arguments (argc, argv)
+ * the last argument is a pointer to a struct ex_ex for
+ * the result. Up do this point, the content of the
+ * struct ex_ex that these functions receive are either
+ * ET_INT (long), ET_FLT (float), or ET_SYM (char **, it is
+ * char ** and not char * since NewHandle of Mac returns
+ * a char ** for relocatability.) The common practice in
+ * these functions is that they figure out the type of their
+ * result according to the type of the arguments. In general
+ * the ET_SYM is used an ET_INT when we expect a value.
+ * It is the users responsibility not to pass strings to the
+ * function.
+ */
+
+#include <stdlib.h>
+
+#define __STRICT_BSD__
+#include <math.h>
+#undef __STRICT_BSD__
+
+
+#include "vexp.h"
+
+/* forward declarations */
+
+static void ex_min(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_max(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_toint(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_rint(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_tofloat(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_pow(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_exp(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_log(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_ln(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_sin(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_cos(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_asin(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_acos(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_tan(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_atan(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_sinh(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_cosh(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_asinh(t_expr *expr, long argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_acosh(t_expr *expr, long argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_tanh(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_atanh(t_expr *expr, long argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_atan2(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_sqrt(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_fact(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_random(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr);
+static void ex_abs(t_expr *expr, long int argc, struct ex_ex *argv, struct ex_ex *optr);
+
+t_ex_func ex_funcs[] = {
+ {"min", ex_min, 2},
+ {"max", ex_max, 2},
+ {"int", ex_toint, 1},
+ {"rint", ex_rint, 1},
+ {"float", ex_tofloat, 1},
+ {"pow", ex_pow, 2},
+ {"sqrt", ex_sqrt, 1},
+ {"exp", ex_exp, 1},
+ {"log10", ex_log, 1},
+ {"ln", ex_ln, 1},
+ {"log", ex_ln, 1},
+ {"sin", ex_sin, 1},
+ {"cos", ex_cos, 1},
+ {"tan", ex_tan, 1},
+ {"asin", ex_asin, 1},
+ {"acos", ex_acos, 1},
+ {"atan", ex_atan, 1},
+ {"atan2", ex_atan2, 2},
+ {"sinh", ex_sinh, 1},
+ {"cosh", ex_cosh, 1},
+ {"tanh", ex_tanh, 1},
+ {"fact", ex_fact, 1},
+ {"random", ex_random, 2}, /* random number */
+ {"abs", ex_abs, 1},
+#ifndef NT
+ {"asinh", ex_asinh, 1},
+ {"acosh", ex_acosh, 1},
+ {"atanh", ex_atanh, 1}, /* hyperbolic atan */
+#endif
+#ifdef PD
+ {"size", ex_size, 1},
+ {"sum", ex_sum, 1},
+ {"Sum", ex_Sum, 3},
+ {"avg", ex_avg, 1},
+ {"Avg", ex_Avg, 3},
+ {"store", ex_store, 3},
+#endif
+ {0, 0, 0}
+};
+
+/*
+ * FUN_EVAL --
+ */
+#define FUNC_EVAL(left, right, func, leftfuncast, rightfuncast, optr) \
+switch (left->ex_type) { \
+case ET_INT: \
+ switch(right->ex_type) { \
+ case ET_INT: \
+ if (optr->ex_type == ET_VEC) { \
+ op = optr->ex_vec; \
+ scalar = (float)func(leftfuncast left->ex_int, \
+ rightfuncast right->ex_int); \
+ j = e->exp_vsize; \
+ while (j--) \
+ *op++ = scalar; \
+ } else { \
+ optr->ex_type = ET_INT; \
+ optr->ex_int = (int)func(leftfuncast left->ex_int, \
+ rightfuncast right->ex_int); \
+ } \
+ break; \
+ case ET_FLT: \
+ if (optr->ex_type == ET_VEC) { \
+ op = optr->ex_vec; \
+ scalar = (float)func(leftfuncast left->ex_int, \
+ rightfuncast right->ex_flt); \
+ j = e->exp_vsize; \
+ while (j--) \
+ *op++ = scalar; \
+ } else { \
+ optr->ex_type = ET_FLT; \
+ optr->ex_flt = (float)func(leftfuncast left->ex_int, \
+ rightfuncast right->ex_flt); \
+ } \
+ break; \
+ case ET_VEC: \
+ case ET_VI: \
+ if (optr->ex_type != ET_VEC) { \
+ if (optr->ex_type == ET_VI) { \
+ post("expr~: Int. error %d", __LINE__); \
+ abort(); \
+ } \
+ optr->ex_type = ET_VEC; \
+ optr->ex_vec = (t_float *) \
+ fts_malloc(sizeof (t_float)*e->exp_vsize); \
+ } \
+ scalar = left->ex_int; \
+ rp = right->ex_vec; \
+ op = optr->ex_vec; \
+ j = e->exp_vsize; \
+ while (j--) { \
+ *op++ = (float)func(leftfuncast scalar, \
+ rightfuncast *rp); \
+ rp++; \
+ } \
+ break; \
+ case ET_SYM: \
+ default: \
+ post_error((fts_object_t *) e, \
+ "expr: FUNC_EVAL(%d): bad right type %ld\n", \
+ __LINE__, right->ex_type);\
+ } \
+ break; \
+case ET_FLT: \
+ switch(right->ex_type) { \
+ case ET_INT: \
+ if (optr->ex_type == ET_VEC) { \
+ op = optr->ex_vec; \
+ scalar = (float)func(leftfuncast left->ex_flt, \
+ rightfuncast right->ex_int); \
+ j = e->exp_vsize; \
+ while (j--) \
+ *op++ = scalar; \
+ } else { \
+ optr->ex_type = ET_INT; \
+ optr->ex_int = (int)func(leftfuncast left->ex_flt, \
+ rightfuncast right->ex_int); \
+ } \
+ break; \
+ case ET_FLT: \
+ if (optr->ex_type == ET_VEC) { \
+ op = optr->ex_vec; \
+ scalar = (float)func(leftfuncast left->ex_flt, \
+ rightfuncast right->ex_flt); \
+ j = e->exp_vsize; \
+ while (j--) \
+ *op++ = scalar; \
+ } else { \
+ optr->ex_type = ET_FLT; \
+ optr->ex_flt = (float)func(leftfuncast left->ex_flt, \
+ rightfuncast right->ex_flt); \
+ } \
+ break; \
+ case ET_VEC: \
+ case ET_VI: \
+ if (optr->ex_type != ET_VEC) { \
+ if (optr->ex_type == ET_VI) { \
+ post("expr~: Int. error %d", __LINE__); \
+ abort(); \
+ } \
+ optr->ex_type = ET_VEC; \
+ optr->ex_vec = (t_float *) \
+ fts_malloc(sizeof (t_float) * e->exp_vsize);\
+ } \
+ scalar = left->ex_flt; \
+ rp = right->ex_vec; \
+ op = optr->ex_vec; \
+ j = e->exp_vsize; \
+ while (j--) { \
+ *op++ = (float)func(leftfuncast scalar, \
+ rightfuncast *rp); \
+ rp++; \
+ } \
+ break; \
+ case ET_SYM: \
+ default: \
+ post_error((fts_object_t *) e, \
+ "expr: FUNC_EVAL(%d): bad right type %ld\n", \
+ __LINE__, right->ex_type);\
+ } \
+ break; \
+case ET_VEC: \
+case ET_VI: \
+ if (optr->ex_type != ET_VEC) { \
+ if (optr->ex_type == ET_VI) { \
+ post("expr~: Int. error %d", __LINE__); \
+ abort(); \
+ } \
+ optr->ex_type = ET_VEC; \
+ optr->ex_vec = (t_float *) \
+ fts_malloc(sizeof (t_float) * e->exp_vsize); \
+ } \
+ op = optr->ex_vec; \
+ lp = left->ex_vec; \
+ switch(right->ex_type) { \
+ case ET_INT: \
+ scalar = right->ex_int; \
+ j = e->exp_vsize; \
+ while (j--) { \
+ *op++ = (float)func(leftfuncast *lp, \
+ rightfuncast scalar); \
+ lp++; \
+ } \
+ break; \
+ case ET_FLT: \
+ scalar = right->ex_flt; \
+ j = e->exp_vsize; \
+ while (j--) { \
+ *op++ = (float)func(leftfuncast *lp, \
+ rightfuncast scalar); \
+ lp++; \
+ } \
+ break; \
+ case ET_VEC: \
+ case ET_VI: \
+ rp = right->ex_vec; \
+ j = e->exp_vsize; \
+ while (j--) { \
+ /* \
+ * on a RISC processor one could copy \
+ * 8 times in each round to get a considerable \
+ * improvement \
+ */ \
+ *op++ = (float)func(leftfuncast *lp, \
+ rightfuncast *rp); \
+ rp++; lp++; \
+ } \
+ break; \
+ case ET_SYM: \
+ default: \
+ post_error((fts_object_t *) e, \
+ "expr: FUNC_EVAL(%d): bad right type %ld\n", \
+ __LINE__, right->ex_type);\
+ } \
+ break; \
+case ET_SYM: \
+default: \
+ post_error((fts_object_t *) e, \
+ "expr: FUNC_EVAL(%d): bad left type %ld\n", \
+ __LINE__, left->ex_type); \
+}
+
+/*
+ * evaluate a unary operator, TYPE is applied to float operands
+ */
+#define FUNC_EVAL_UNARY(left, func, leftcast, optr) \
+switch(left->ex_type) { \
+case ET_INT: \
+ if (optr->ex_type == ET_VEC) { \
+ ex_mkvector(optr->ex_vec, \
+ (float)(func (leftcast left->ex_int)), e->exp_vsize);\
+ break; \
+ } \
+ optr->ex_type = ET_INT; \
+ optr->ex_int = (int) func(leftcast left->ex_int); \
+ break; \
+case ET_FLT: \
+ if (optr->ex_type == ET_VEC) { \
+ ex_mkvector(optr->ex_vec, \
+ (float)(func (leftcast left->ex_flt)), e->exp_vsize);\
+ break; \
+ } \
+ optr->ex_type = ET_FLT; \
+ optr->ex_flt = (float) func(leftcast left->ex_flt); \
+ break; \
+case ET_VI: \
+case ET_VEC: \
+ if (optr->ex_type != ET_VEC) { \
+ optr->ex_type = ET_VEC; \
+ optr->ex_vec = (t_float *) \
+ fts_malloc(sizeof (t_float)*e->exp_vsize); \
+ } \
+ op = optr->ex_vec; \
+ lp = left->ex_vec; \
+ j = e->exp_vsize; \
+ while (j--) \
+ *op++ = (float)(func (leftcast *lp++)); \
+ break; \
+default: \
+ post_error((fts_object_t *) e, \
+ "expr: FUNV_EVAL_UNARY(%d): bad left type %ld\n",\
+ __LINE__, left->ex_type); \
+}
+
+#undef min
+#undef max
+#define min(x,y) (x > y ? y : x)
+#define max(x,y) (x > y ? x : y)
+
+/*
+ * ex_min -- if any of the arfuments are or the output are vectors, a vector
+ * of floats is generated otherwise the type of the result is the
+ * type of the smaller value
+ */
+static void
+ex_min(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr)
+{
+ struct ex_ex *left, *right;
+ float *op; /* output pointer */
+ float *lp, *rp; /* left and right vector pointers */
+ float scalar;
+ int j;
+
+ left = argv++;
+ right = argv;
+
+ /* minimum needs no cast, as it is not a real function */
+ FUNC_EVAL(left, right, min, (double), (double), optr);
+}
+
+/*
+ * ex_max -- if any of the arfuments are or the output are vectors, a vector
+ * of floats is generated otherwise the type of the result is the
+ * type of the larger value
+ */
+static void
+ex_max(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr)
+{
+ struct ex_ex *left, *right;
+ float *op; /* output pointer */
+ float *lp, *rp; /* left and right vector pointers */
+ float scalar;
+ int j;
+
+ left = argv++;
+ right = argv;
+
+ /* minimum needs no cast, as it is not a real function */
+ FUNC_EVAL(left, right, max, (double), (double), optr);
+}
+
+/* SDY changed to new form up to here */
+
+/*
+ * ex_toint -- convert to integer
+ */
+static void
+ex_toint(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr)
+{
+ struct ex_ex *left;
+ float *op; /* output pointer */
+ float *lp, *rp; /* left and right vector pointers */
+ float scalar;
+ int j;
+
+ left = argv++;
+
+#define toint(x) ((int)(x))
+ FUNC_EVAL_UNARY(left, toint, (int), optr);
+}
+
+#ifdef NT
+/* No rint in NT land ??? */
+double rint(double x);
+
+double
+rint(double x)
+{
+ return (floor(x + 0.5));
+}
+#endif
+
+/*
+ * ex_rint -- rint() round to the nearest int according to the common
+ * rounding mechanism
+ */
+static void
+ex_rint(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr)
+{
+ struct ex_ex *left;
+ float *op; /* output pointer */
+ float *lp, *rp; /* left and right vector pointers */
+ float scalar;
+ int j;
+
+ left = argv++;
+
+
+ FUNC_EVAL_UNARY(left, rint, (double), optr);
+
+#ifdef old
+
+ if (argv->ex_type == ET_INT)
+ *optr = *argv;
+ else if (argv->ex_type == ET_FLT) {
+ optr->ex_type = ET_FLT;
+#ifdef NT /* no rint() in NT??? */
+ optr->ex_flt = floor(argv->ex_flt + 0.5);
+#else
+ optr->ex_flt = rint(argv->ex_flt);
+#endif
+ } else {
+/* SDY what does this mean? this is wrong!!???? */
+ optr->ex_type = ET_INT;
+ optr->ex_int = (int)argv->ex_ptr;
+ }
+#endif
+}
+
+/*
+ * ex_tofloat -- convert to float
+ */
+static void
+ex_tofloat(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr)
+{
+ struct ex_ex *left;
+ float *op; /* output pointer */
+ float *lp, *rp; /* left and right vector pointers */
+ float scalar;
+ int j;
+
+ left = argv++;
+
+#define tofloat(x) ((float)(x))
+ FUNC_EVAL_UNARY(left, toint, (int), optr);
+}
+
+
+/*
+ * ex_pow -- the power of
+ */
+static void
+ex_pow(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr)
+{
+ struct ex_ex *left, *right;
+ float *op; /* output pointer */
+ float *lp, *rp; /* left and right vector pointers */
+ float scalar;
+ int j;
+
+ left = argv++;
+ right = argv;
+ FUNC_EVAL(left, right, pow, (double), (double), optr);
+}
+
+/*
+ * ex_sqrt -- square root
+ */
+static void
+ex_sqrt(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr)
+{
+ struct ex_ex *left;
+ float *op; /* output pointer */
+ float *lp, *rp; /* left and right vector pointers */
+ float scalar;
+ int j;
+
+ left = argv++;
+
+ FUNC_EVAL_UNARY(left, sqrt, (double), optr);
+}
+
+/*
+ * ex_exp -- e to the power of
+ */
+static void
+ex_exp(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr)
+{
+ struct ex_ex *left;
+ float *op; /* output pointer */
+ float *lp, *rp; /* left and right vector pointers */
+ float scalar;
+ int j;
+
+ left = argv++;
+
+ FUNC_EVAL_UNARY(left, exp, (double), optr);
+}
+
+/*
+ * ex_log -- 10 based logarithm
+ */
+static void
+ex_log(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr)
+{
+ struct ex_ex *left;
+ float *op; /* output pointer */
+ float *lp, *rp; /* left and right vector pointers */
+ float scalar;
+ int j;
+
+ left = argv++;
+
+ FUNC_EVAL_UNARY(left, log10, (double), optr);
+}
+
+/*
+ * ex_ln -- natural log
+ */
+static void
+ex_ln(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr)
+{
+ struct ex_ex *left;
+ float *op; /* output pointer */
+ float *lp, *rp; /* left and right vector pointers */
+ float scalar;
+ int j;
+
+ left = argv++;
+
+ FUNC_EVAL_UNARY(left, log, (double), optr);
+}
+
+static void
+ex_sin(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr)
+{
+ struct ex_ex *left;
+ float *op; /* output pointer */
+ float *lp, *rp; /* left and right vector pointers */
+ float scalar;
+ int j;
+
+ left = argv++;
+
+ FUNC_EVAL_UNARY(left, sin, (double), optr);
+}
+
+static void
+ex_cos(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr)
+{
+ struct ex_ex *left;
+ float *op; /* output pointer */
+ float *lp, *rp; /* left and right vector pointers */
+ float scalar;
+ int j;
+
+ left = argv++;
+
+ FUNC_EVAL_UNARY(left, cos, (double), optr);
+}
+
+
+static void
+ex_tan(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr)
+{
+ struct ex_ex *left;
+ float *op; /* output pointer */
+ float *lp, *rp; /* left and right vector pointers */
+ float scalar;
+ int j;
+
+ left = argv++;
+
+ FUNC_EVAL_UNARY(left, tan, (double), optr);
+}
+
+static void
+ex_asin(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr)
+{
+ struct ex_ex *left;
+ float *op; /* output pointer */
+ float *lp, *rp; /* left and right vector pointers */
+ float scalar;
+ int j;
+
+ left = argv++;
+
+ FUNC_EVAL_UNARY(left, asin, (double), optr);
+}
+
+static void
+ex_acos(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr)
+{
+ struct ex_ex *left;
+ float *op; /* output pointer */
+ float *lp, *rp; /* left and right vector pointers */
+ float scalar;
+ int j;
+
+ left = argv++;
+
+ FUNC_EVAL_UNARY(left, acos, (double), optr);
+}
+
+
+static void
+ex_atan(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr)
+{
+ struct ex_ex *left;
+ float *op; /* output pointer */
+ float *lp, *rp; /* left and right vector pointers */
+ float scalar;
+ int j;
+
+ left = argv++;
+
+ FUNC_EVAL_UNARY(left, atan, (double), optr);
+}
+
+/*
+ *ex_atan2 --
+ */
+static void
+ex_atan2(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr)
+{
+ struct ex_ex *left, *right;
+ float *op; /* output pointer */
+ float *lp, *rp; /* left and right vector pointers */
+ float scalar;
+ int j;
+
+ left = argv++;
+ right = argv;
+ FUNC_EVAL(left, right, atan2, (double), (double), optr);
+}
+
+
+static void
+ex_sinh(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr)
+{
+ struct ex_ex *left;
+ float *op; /* output pointer */
+ float *lp, *rp; /* left and right vector pointers */
+ float scalar;
+ int j;
+
+ left = argv++;
+
+ FUNC_EVAL_UNARY(left, sinh, (double), optr);
+}
+
+static void
+ex_cosh(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr)
+{
+ struct ex_ex *left;
+ float *op; /* output pointer */
+ float *lp, *rp; /* left and right vector pointers */
+ float scalar;
+ int j;
+
+ left = argv++;
+
+ FUNC_EVAL_UNARY(left, cosh, (double), optr);
+}
+
+
+static void
+ex_tanh(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr)
+{
+ struct ex_ex *left;
+ float *op; /* output pointer */
+ float *lp, *rp; /* left and right vector pointers */
+ float scalar;
+ int j;
+
+ left = argv++;
+
+ FUNC_EVAL_UNARY(left, tanh, (double), optr);
+}
+
+
+#ifndef NT
+static void
+ex_asinh(t_expr *e, long argc, struct ex_ex *argv, struct ex_ex *optr)
+{
+ struct ex_ex *left;
+ float *op; /* output pointer */
+ float *lp, *rp; /* left and right vector pointers */
+ float scalar;
+ int j;
+
+ left = argv++;
+
+ FUNC_EVAL_UNARY(left, asinh, (double), optr);
+}
+
+static void
+ex_acosh(t_expr *e, long argc, struct ex_ex *argv, struct ex_ex *optr)
+{
+ struct ex_ex *left;
+ float *op; /* output pointer */
+ float *lp, *rp; /* left and right vector pointers */
+ float scalar;
+ int j;
+
+ left = argv++;
+
+ FUNC_EVAL_UNARY(left, acosh, (double), optr);
+}
+
+static void
+ex_atanh(t_expr *e, long argc, struct ex_ex *argv, struct ex_ex *optr)
+{
+ struct ex_ex *left;
+ float *op; /* output pointer */
+ float *lp, *rp; /* left and right vector pointers */
+ float scalar;
+ int j;
+
+ left = argv++;
+
+ FUNC_EVAL_UNARY(left, atanh, (double), optr);
+}
+#endif
+
+static int
+ex_dofact(int i)
+{
+ int ret = 0;
+
+ if (i)
+ ret = 1;
+ else
+ return (0);
+
+ do {
+ ret *= i;
+ } while (--i);
+
+ return(ret);
+}
+
+static void
+ex_fact(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr)
+{
+ struct ex_ex *left;
+ float *op; /* output pointer */
+ float *lp, *rp; /* left and right vector pointers */
+ float scalar;
+ int j;
+
+ left = argv++;
+
+ FUNC_EVAL_UNARY(left, ex_dofact, (int), optr);
+}
+
+static int
+ex_dorandom(int i1, int i2)
+{
+ return(i1 + (((i2 - i1) * (rand() & 0x7fffL)) >> 15));
+}
+/*
+ * ex_random -- return a random number
+ */
+static void
+ex_random(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr)
+{
+ struct ex_ex *left, *right;
+ float *op; /* output pointer */
+ float *lp, *rp; /* left and right vector pointers */
+ float scalar;
+ int j;
+
+ left = argv++;
+ right = argv;
+ FUNC_EVAL(left, right, ex_dorandom, (int), (int), optr);
+}
+
+
+static void
+ex_abs(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr)
+{
+ struct ex_ex *left;
+ float *op; /* output pointer */
+ float *lp, *rp; /* left and right vector pointers */
+ float scalar;
+ int j;
+
+ left = argv++;
+
+ FUNC_EVAL_UNARY(left, fabs, (double), optr);
+}
+
diff --git a/pd/extra/expr~/vexp_if.c b/pd/extra/expr~/vexp_if.c
new file mode 100644
index 00000000..6d86ff1c
--- /dev/null
+++ b/pd/extra/expr~/vexp_if.c
@@ -0,0 +1,931 @@
+/*
+ * jMax
+ * Copyright (C) 1994, 1995, 1998, 1999 by IRCAM-Centre Georges Pompidou, Paris, France.
+ *
+ * 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.
+ *
+ * See file LICENSE for further informations on licensing terms.
+ *
+ * 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.
+ *
+ * Based on Max/ISPW by Miller Puckette.
+ *
+ * Authors: Maurizio De Cecco, Francois Dechelle, Enzo Maggi, Norbert Schnell.
+ *
+ */
+
+/* "expr" was written by Shahrokh Yadegari c. 1989. -msp */
+/* "expr~" and "fexpr~" conversion by Shahrokh Yadegari c. 1999,2000 */
+
+#include <stdio.h>
+#include <stdlib.h>
+
+
+#include "vexp.h"
+#ifndef MSP
+#ifndef MACOSX
+/*
+ * the compiler on mac seems not to like this, perhaps we could get away with
+ * not having it at all.
+ */
+#include "stdlib.h"
+#endif
+#endif
+#include "string.h"
+
+static char *exp_version = "0.3";
+
+extern struct ex_ex *ex_eval(struct expr *exp, struct ex_ex *eptr,
+ struct ex_ex *optr, int n);
+
+#ifdef PD
+static t_class *expr_class;
+static t_class *expr_tilde_class;
+static t_class *fexpr_tilde_class;
+#else /* MSP */
+void *expr_tilde_class;
+#endif
+
+
+/*------------------------- expr class -------------------------------------*/
+
+extern int expr_donew(struct expr *expr, int ac, t_atom *av);
+
+/*#define EXPR_DEBUG*/
+
+static void expr_bang(t_expr *x);
+t_int *expr_perform(t_int *w);
+
+
+static void
+expr_list(t_expr *x, t_symbol *s, int argc, const fts_atom_t *argv)
+{
+ int i;
+
+ if (argc > MAX_VARS) argc = MAX_VARS;
+
+ for (i = 0; i < argc; i++)
+ {
+ if (argv[i].a_type == A_FLOAT)
+ {
+ if (x->exp_var[i].ex_type == ET_FI)
+ x->exp_var[i].ex_flt = argv[i].a_w.w_float;
+ else if (x->exp_var[i].ex_type == ET_II)
+ x->exp_var[i].ex_int = argv[i].a_w.w_float;
+ else pd_error(x, "expr: type mismatch");
+ }
+ else if (argv[i].a_type == A_SYMBOL)
+ {
+ if (x->exp_var[i].ex_type == ET_SI)
+ x->exp_var[i].ex_ptr = (char *)argv[i].a_w.w_symbol;
+ else pd_error(x, "expr: type mismatch");
+ }
+ }
+ expr_bang(x);
+}
+
+static void
+expr_flt(t_expr *x, t_float f, int in)
+{
+ if (in > MAX_VARS)
+ return;
+
+ if (x->exp_var[in].ex_type == ET_FI)
+ x->exp_var[in].ex_flt = f;
+ else if (x->exp_var[in].ex_type == ET_II)
+ x->exp_var[in].ex_int = f;
+}
+
+static t_class *exprproxy_class;
+
+typedef struct _exprproxy {
+ t_pd p_pd;
+ int p_index;
+ t_expr *p_owner;
+ struct _exprproxy *p_next;
+} t_exprproxy;
+
+t_exprproxy *exprproxy_new(t_expr *owner, int indx);
+void exprproxy_float(t_exprproxy *p, t_floatarg f);
+
+t_exprproxy *
+exprproxy_new(t_expr *owner, int indx)
+{
+ t_exprproxy *x = (t_exprproxy *)pd_new(exprproxy_class);
+ x->p_owner = owner;
+ x->p_index = indx;
+ x->p_next = owner->exp_proxy;
+ owner->exp_proxy = x;
+ return (x);
+}
+
+void
+exprproxy_float(t_exprproxy *p, t_floatarg f)
+{
+ t_expr *x = p->p_owner;
+ int in = p->p_index;
+
+ if (in > MAX_VARS)
+ return;
+
+ if (x->exp_var[in].ex_type == ET_FI)
+ x->exp_var[in].ex_flt = f;
+ else if (x->exp_var[in].ex_type == ET_II)
+ x->exp_var[in].ex_int = f;
+}
+
+/* method definitions */
+static void
+expr_ff(t_expr *x)
+{
+ t_exprproxy *y;
+
+ y = x->exp_proxy;
+ while (y)
+ {
+ x->exp_proxy = y->p_next;
+#ifdef PD
+ pd_free(&y->p_pd);
+#else /*MSP */
+ /* SDY find out what needs to be called for MSP */
+
+#endif
+ y = x->exp_proxy;
+ }
+ if (x->exp_stack)
+ fts_free(x->exp_stack);
+/*
+ * SDY free all the allocated buffers here for expr~ and fexpr~
+ */
+}
+
+static void
+expr_bang(t_expr *x)
+{
+
+#ifdef EXPR_DEBUG
+ {
+ int i;
+ struct ex_ex *eptr;
+
+ for (i = 0, eptr = x->exp_var; ; eptr++, i++)
+ {
+ if (!eptr->ex_type)
+ break;
+ switch (eptr->ex_type)
+ {
+ case ET_II:
+ fprintf(stderr,"ET_II: %d \n", eptr->ex_int);
+ break;
+
+ case ET_FI:
+ fprintf(stderr,"ET_FT: %f \n", eptr->ex_flt);
+ break;
+
+ default:
+ fprintf(stderr,"oups\n");
+ }
+ }
+ }
+#endif
+ /* banging a signal or filter object means nothing */
+ if (!IS_EXPR(x))
+ return;
+
+ if (!ex_eval(x, x->exp_stack, &x->exp_res, 0))
+ {
+ /* fprintf(stderr,"expr_bang(error evaluation)\n"); */
+ return;
+ }
+
+
+ switch(x->exp_res.ex_type)
+ {
+ case ET_INT:
+ outlet_float(x->exp_outlet, (t_float) x->exp_res.ex_int);
+ break;
+
+ case ET_FLT:
+ outlet_float(x->exp_outlet, x->exp_res.ex_flt);
+ break;
+
+ case ET_SYM:
+ /* CHANGE this will have to be taken care of */
+
+ default:
+ post("expr: bang: unrecognized result %ld\n", x->exp_res.ex_type);
+ }
+}
+
+static t_expr *
+#ifdef PD
+expr_new(t_symbol *s, int ac, t_atom *av)
+#else /* MSP */
+Nexpr_new(t_symbol *s, int ac, t_atom *av)
+#endif
+{
+ struct expr *x;
+ int i, ninlet;
+ struct ex_ex *eptr;
+ t_atom fakearg;
+ int dsp_index; /* keeping track of the dsp inlets */
+
+
+/*
+ * SDY - we may need to call dsp_setup() in this function
+ */
+
+ if (!ac)
+ {
+ ac = 1;
+ av = &fakearg;
+ SETFLOAT(&fakearg, 0);
+ }
+
+#ifdef PD
+ /*
+ * figure out if we are expr, expr~, or fexpr~
+ */
+ if (!strcmp("expr", s->s_name)) {
+ x = (t_expr *)pd_new(expr_class);
+ SET_EXPR(x);
+ } else if (!strcmp("expr~", s->s_name)) {
+ x = (t_expr *)pd_new(expr_tilde_class);
+ SET_EXPR_TILDE(x);
+ } else if (!strcmp("fexpr~", s->s_name)) {
+ x = (t_expr *)pd_new(fexpr_tilde_class);
+ SET_FEXPR_TILDE(x);
+ } else {
+ post("expr_new: bad object name '%s'");
+ /* assume expr */
+ x = (t_expr *)pd_new(expr_class);
+ SET_EXPR(x);
+ }
+#else /* MSP */
+ /* for now assume an expr~ */
+ x = (t_expr *)pd_new(expr_tilde_class);
+ SET_EXPR_TILDE(x);
+#endif
+
+ /*
+ * initialize the newly allocated object
+ */
+ x->exp_stack = (struct ex_ex *)0;
+ x->exp_proxy = 0;
+ x->exp_nivec = 0;
+ x->exp_error = 0;
+ x->exp_outlet = (t_outlet *)0;
+ x->exp_res.ex_type = 0;
+ x->exp_res.ex_int = 0;
+ x->exp_p_res = (t_float *)0;
+ x->exp_tmpres = (t_float *)0;
+ for (i = 0; i < MAX_VARS; i++) {
+ x->exp_var[i].ex_type = 0;
+ x->exp_var[i].ex_int = 0;
+ x->exp_p_var[i] = (t_float *)0;
+ }
+ x->exp_f = 0; /* save the control value to be transformed to signal */
+
+
+ if (expr_donew(x, ac, av))
+ {
+ pd_error(x, "expr: syntax error");
+/*
+SDY the following coredumps why?
+ pd_free(&x->exp_ob.ob_pd);
+*/
+ return (0);
+ }
+
+ ninlet = 1;
+ for (i = 0, eptr = x->exp_var; i < MAX_VARS ; i++, eptr++)
+ if (eptr->ex_type) {
+ ninlet = i + 1;
+ }
+
+ /*
+ * create the new inlets
+ */
+ for (i = 1, eptr = x->exp_var + 1, dsp_index=1; i<ninlet ; i++, eptr++)
+ {
+ t_exprproxy *p;
+ switch (eptr->ex_type)
+ {
+ case 0:
+ /* nothing is using this inlet */
+ if (i < ninlet)
+#ifdef PD
+ floatinlet_new(&x->exp_ob, &eptr->ex_flt);
+#else /* MSP */
+ inlet_new(&x->exp_ob, "float");
+#endif
+ break;
+
+ case ET_II:
+ case ET_FI:
+ p = exprproxy_new(x, i);
+#ifdef PD
+ inlet_new(&x->exp_ob, &p->p_pd, &s_float, &s_float);
+#else /* MSP */
+ inlet_new(&x->exp_ob, "float");
+#endif
+ break;
+
+ case ET_SI:
+#ifdef PD
+ symbolinlet_new(&x->exp_ob, (t_symbol **)&eptr->ex_ptr);
+#else /* MSP */
+ inlet_new(&x->exp_ob, "symbol");
+#endif
+ break;
+
+ case ET_XI:
+ case ET_VI:
+ if (!IS_EXPR(x)) {
+ dsp_index++;
+#ifdef PD
+ inlet_new(&x->exp_ob, &x->exp_ob.ob_pd,
+ &s_signal, &s_signal);
+#else /* MSP */
+ inlet_new(&x->exp_ob, "signal");
+#endif
+ break;
+ } else
+ post("expr: internal error expr_new");
+ default:
+ pd_error(x, "expr: bad type (%lx) inlet = %d\n",
+ eptr->ex_type, i + 1, 0, 0, 0);
+ break;
+ }
+ }
+ if (IS_EXPR(x)) {
+ x->exp_outlet = outlet_new(&x->exp_ob, 0);
+ } else {
+#ifdef PD
+ x->exp_outlet = outlet_new(&x->exp_ob, gensym("signal"));
+#else /* MSP */
+ x->exp_outlet = outlet_new(&x->exp_ob, "signal");
+#endif
+ x->exp_nivec = dsp_index;
+ }
+
+ return (x);
+}
+
+t_int *
+expr_perform(t_int *w)
+{
+ int i;
+ t_expr *x = (t_expr *)w[1];
+ struct ex_ex res;
+ int n;
+
+ /* sanity check */
+ if (IS_EXPR(x)) {
+ post("expr_perform: bad x->exp_flags = %d", x->exp_flags);
+ abort();
+ }
+
+ if (x->exp_flags & EF_STOP) {
+ memset(x->exp_res.ex_vec, 0, x->exp_vsize * sizeof (float));
+ return (w + 2);
+ }
+
+ if (IS_EXPR_TILDE(x)) {
+ ex_eval(x, x->exp_stack, &x->exp_res, 0);
+ return (w + 2);
+ }
+
+ if (!IS_FEXPR_TILDE(x)) {
+ post("expr_perform: bad x->exp_flags = %d - expecting fexpr",
+ x->exp_flags);
+ abort();
+ }
+ /*
+ * since the output buffer could be the same as one of the inputs
+ * we need to keep the output in a different buffer
+ */
+ for (i = 0; i < x->exp_vsize; i++) {
+ res.ex_type = 0;
+ res.ex_int = 0;
+ ex_eval(x, x->exp_stack, &res, i);
+ switch (res.ex_type) {
+ case ET_INT:
+ x->exp_tmpres[i] = (t_float) res.ex_int;
+ break;
+ case ET_FLT:
+ x->exp_tmpres[i] = res.ex_flt;
+ break;
+ default:
+ post("expr_perform: bad result type %d", res.ex_type);
+ }
+ }
+ /*
+ * copy inputs and results to the save buffers
+ * inputs need to be copied first as the output buffer can be
+ * same as an input buffer
+ */
+ n = x->exp_vsize * sizeof(t_float);
+ for (i = 0; i < MAX_VARS; i++)
+ if (x->exp_var[i].ex_type == ET_XI)
+ memcpy(x->exp_p_var[i], x->exp_var[i].ex_vec, n);
+ memcpy(x->exp_p_res, x->exp_tmpres, n);
+ memcpy(x->exp_res.ex_vec, x->exp_tmpres, n);
+ return (w + 2);
+}
+
+static void
+expr_dsp(t_expr *x, t_signal **sp)
+{
+ int i, nv;
+ int newsize;
+
+ x->exp_error = 0; /* reset all errors */
+ newsize = (x->exp_vsize != sp[0]->s_n);
+ x->exp_vsize = sp[0]->s_n; /* record the vector size */
+ x->exp_res.ex_type = ET_VEC;
+ x->exp_res.ex_vec = sp[x->exp_nivec]->s_vec;
+ for (i = 0, nv = 0; i < MAX_VARS; i++)
+ /*
+ * the first inlet is always a signal
+ *
+ * SDY We are warning the user till this limitation
+ * is taken away from pd
+ */
+ if (!i || x->exp_var[i].ex_type == ET_VI ||
+ x->exp_var[i].ex_type == ET_XI) {
+ if (nv >= x->exp_nivec) {
+ post("expr_dsp int. err nv = %d, x->exp_nive = %d",
+ nv, x->exp_nivec);
+ abort();
+ }
+ x->exp_var[i].ex_vec = sp[nv]->s_vec;
+ nv++;
+ }
+ /* we always have one inlet but we may not use it */
+ if (nv != x->exp_nivec && (nv != 0 || x->exp_nivec != 1)) {
+ post("expr_dsp internal error 2 nv = %d, x->exp_nive = %d",
+ nv, x->exp_nivec);
+ abort();
+ }
+
+ dsp_add(expr_perform, 1, (t_int *) x);
+
+ if (!IS_FEXPR_TILDE(x))
+ return;
+ if (x->exp_p_res) {
+ if (!newsize)
+ return;
+ /*
+ * if new size, reallocate all the previous buffers for fexpr~
+ */
+ fts_free(x->exp_p_res);
+ fts_free(x->exp_tmpres);
+ for (i = 0; i < MAX_VARS; i++)
+ fts_free(x->exp_p_var[i]);
+
+ }
+ x->exp_p_res = fts_calloc(x->exp_vsize, sizeof (t_float));
+ x->exp_tmpres = fts_calloc(x->exp_vsize, sizeof (t_float));
+ for (i = 0; i < MAX_VARS; i++)
+ x->exp_p_var[i] = fts_calloc(x->exp_vsize, sizeof (t_float));
+}
+
+/*
+ * expr_start -- turn on expr processing for now only used for fexpr~
+ */
+static void
+expr_start(t_expr *x)
+{
+ x->exp_flags &= ~EF_STOP;
+}
+
+/*
+ * expr_stop -- turn on expr processing for now only used for fexpr~
+ */
+static void
+expr_stop(t_expr *x)
+{
+ x->exp_flags |= EF_STOP;
+}
+
+#ifdef PD
+
+void
+expr_setup(void)
+{
+ /*
+ * expr initialization
+ */
+ expr_class = class_new(gensym("expr"), (t_newmethod)expr_new,
+ (t_method)expr_ff, sizeof(t_expr), 0, A_GIMME, 0);
+ class_addlist(expr_class, expr_list);
+ exprproxy_class = class_new(gensym("exprproxy"), 0,
+ 0, sizeof(t_exprproxy), CLASS_PD, 0);
+ class_addfloat(exprproxy_class, exprproxy_float);
+
+ /*
+ * expr~ initialization
+ */
+ expr_tilde_class = class_new(gensym("expr~"), (t_newmethod)expr_new,
+ (t_method)expr_ff, sizeof(t_expr), 0, A_GIMME, 0);
+ class_addmethod(expr_tilde_class, nullfn, gensym("signal"), 0);
+ CLASS_MAINSIGNALIN(expr_tilde_class, t_expr, exp_f);
+ class_addmethod(expr_tilde_class,(t_method)expr_dsp, gensym("dsp"), 0);
+
+ /*
+ * fexpr~ initialization
+ */
+ fexpr_tilde_class = class_new(gensym("fexpr~"), (t_newmethod)expr_new,
+ (t_method)expr_ff, sizeof(t_expr), 0, A_GIMME, 0);
+ class_addmethod(fexpr_tilde_class, nullfn, gensym("signal"), 0);
+ class_addmethod(fexpr_tilde_class,(t_method)expr_start,
+ gensym("start"), 0);
+ class_addmethod(fexpr_tilde_class,(t_method)expr_stop,
+ gensym("stop"), 0);
+
+ class_addmethod(fexpr_tilde_class,(t_method)expr_dsp,gensym("dsp"), 0);
+
+ post("expr, expr~, fexpr~ version %s under GNU General Public License ", exp_version);
+
+}
+
+void
+expr_tilde_setup(void)
+{
+ expr_setup();
+}
+
+void
+fexpr_tilde_setup(void)
+{
+ expr_setup();
+}
+#else /* MSP */
+void
+main(void)
+{
+ setup((t_messlist **)&expr_tilde_class, (method)Nexpr_new,
+ (method)expr_ff, (short)sizeof(t_expr), 0L, A_GIMME, 0);
+ addmess((method)expr_dsp, "dsp", A_CANT, 0); // dsp method
+ dsp_initclass();
+}
+#endif
+
+
+/* -- the following functions use Pd internals and so are in the "if" file. */
+
+
+int ex_getsym(char *p, fts_symbol_t *s)
+{
+ *s = gensym(p);
+ return (0);
+}
+
+const char *
+ex_symname(fts_symbol_t s)
+{
+ return (fts_symbol_name(s));
+}
+
+/*
+ * max_ex_tab -- evaluate this table access
+ * eptr is the name of the table and arg is the index we
+ * have to put the result in optr
+ * return 1 on error and 0 otherwise
+ *
+ * Arguments:
+ * the expr object
+ * table
+ * the argument
+ * the result pointer
+ */
+int
+max_ex_tab(struct expr *exp,fts_symbol_t s,struct ex_ex *arg,struct ex_ex *optr)
+{
+#ifdef PD
+ t_garray *garray;
+ int size, indx;
+ t_float *vec;
+
+ if (!s || !(garray = (t_garray *)pd_findbyclass(s, garray_class)) ||
+ !garray_getfloatarray(garray, &size, &vec))
+ {
+ optr->ex_type = ET_FLT;
+ optr->ex_int = 0;
+ pd_error(exp, "no such table '%s'", s->s_name);
+ return (1);
+ }
+ optr->ex_type = ET_FLT;
+
+ switch (arg->ex_type) {
+ case ET_INT:
+ indx = arg->ex_int;
+ break;
+ case ET_FLT:
+ /* strange interpolation code deleted here -msp */
+ indx = arg->ex_flt;
+ break;
+
+ default: /* do something with strings */
+ pd_error(exp, "expr: bad argument for table '%s'\n", fts_symbol_name(s));
+ indx = 0;
+ }
+ if (indx < 0) indx = 0;
+ else if (indx >= size) indx = size - 1;
+ optr->ex_flt = vec[indx];
+#else /* MSP */
+ /*
+ * table lookup not done for MSP yet
+ */
+ post("max_ex_tab: not complete for MSP yet!");
+ optr->ex_type = ET_FLT;
+ optr->ex_flt = 0;
+#endif
+ return (0);
+}
+
+#ifdef PD /* this goes to the end of this file as the following functions
+ * should be defined in the expr object in MSP
+ */
+#define ISTABLE(sym, garray, size, vec) \
+if (!sym || !(garray = (t_garray *)pd_findbyclass(sym, garray_class)) || \
+ !garray_getfloatarray(garray, &size, &vec)) { \
+ optr->ex_type = ET_FLT; \
+ optr->ex_int = 0; \
+ error("no such table '%s'", sym->s_name); \
+ return; \
+}
+
+/*
+ * ex_size -- find the size of a table
+ */
+void
+ex_size(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr)
+{
+ t_symbol *s;
+ t_garray *garray;
+ int size;
+ t_float *vec;
+
+ if (argv->ex_type != ET_SYM)
+ {
+ post("expr: size: need a table name\n");
+ optr->ex_type = ET_INT;
+ optr->ex_int = 0;
+ return;
+ }
+
+ s = (fts_symbol_t ) argv->ex_ptr;
+
+ ISTABLE(s, garray, size, vec);
+
+ optr->ex_type = ET_INT;
+ optr->ex_int = size;
+}
+
+/*
+ * ex_sum -- calculate the sum of all elements of a table
+ */
+
+void
+ex_sum(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr)
+{
+ t_symbol *s;
+ t_garray *garray;
+ int size;
+ t_float *vec, sum;
+ int indx;
+
+ if (argv->ex_type != ET_SYM)
+ {
+ post("expr: sum: need a table name\n");
+ optr->ex_type = ET_INT;
+ optr->ex_int = 0;
+ return;
+ }
+
+ s = (fts_symbol_t ) argv->ex_ptr;
+
+ ISTABLE(s, garray, size, vec);
+
+ for (indx = 0, sum = 0; indx < size; indx++)
+ sum += vec[indx];
+
+ optr->ex_type = ET_FLT;
+ optr->ex_flt = sum;
+}
+
+
+/*
+ * ex_Sum -- calculate the sum of table with the given boundries
+ */
+
+void
+ex_Sum(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr)
+{
+ t_symbol *s;
+ t_garray *garray;
+ int size;
+ t_float *vec, sum;
+ int indx, n1, n2;
+
+ if (argv->ex_type != ET_SYM)
+ {
+ post("expr: sum: need a table name\n");
+ optr->ex_type = ET_INT;
+ optr->ex_int = 0;
+ return;
+ }
+
+ s = (fts_symbol_t ) argv->ex_ptr;
+
+ ISTABLE(s, garray, size, vec);
+
+ if (argv->ex_type != ET_INT || argv[1].ex_type != ET_INT)
+ {
+ post("expr: Sum: boundries have to be fix values\n");
+ optr->ex_type = ET_INT;
+ optr->ex_int = 0;
+ return;
+ }
+ n1 = argv->ex_int;
+ n2 = argv[1].ex_int;
+
+ for (indx = n1, sum = 0; indx < n2; indx++)
+ if (indx >= 0 && indx < size)
+ sum += vec[indx];
+
+ optr->ex_type = ET_FLT;
+ optr->ex_flt = sum;
+}
+
+/*
+ * ex_avg -- calculate the avarage of a table
+ */
+
+void
+ex_avg(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr)
+{
+/* SDY - look into this function */
+#if 0
+ fts_symbol_t s;
+ fts_integer_vector_t *tw = 0;
+
+ if (argv->ex_type != ET_SYM)
+ {
+ post("expr: avg: need a table name\n");
+ optr->ex_type = ET_INT;
+ optr->ex_int = 0;
+ }
+
+ s = (fts_symbol_t ) argv->ex_ptr;
+
+ tw = table_integer_vector_get_by_name(s);
+
+ if (tw)
+ {
+ optr->ex_type = ET_INT;
+
+ if (! fts_integer_vector_get_size(tw))
+ optr->ex_int = 0;
+ else
+ optr->ex_int = fts_integer_vector_get_sum(tw) / fts_integer_vector_get_size(tw);
+ }
+ else
+ {
+ optr->ex_type = ET_INT;
+ optr->ex_int = 0;
+ post("expr: avg: no such table %s\n", fts_symbol_name(s));
+ }
+#endif
+}
+
+
+/*
+ * ex_Avg -- calculate the avarage of table with the given boundries
+ */
+
+void
+ex_Avg(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr)
+{
+/* SDY - look into this function */
+#if 0
+ fts_symbol_t s;
+ fts_integer_vector_t *tw = 0;
+
+ if (argv->ex_type != ET_SYM)
+ {
+ post("expr: Avg: need a table name\n");
+ optr->ex_type = ET_INT;
+ optr->ex_int = 0;
+ }
+
+ s = (fts_symbol_t ) (argv++)->ex_ptr;
+
+ tw = table_integer_vector_get_by_name(s);
+
+ if (! tw)
+ {
+ optr->ex_type = ET_INT;
+ optr->ex_int = 0;
+ post("expr: Avg: no such table %s\n", fts_symbol_name(s));
+ return;
+ }
+
+ if (argv->ex_type != ET_INT || argv[1].ex_type != ET_INT)
+ {
+ post("expr: Avg: boundries have to be fix values\n");
+ optr->ex_type = ET_INT;
+ optr->ex_int = 0;
+ return;
+ }
+
+ optr->ex_type = ET_INT;
+
+ if (argv[1].ex_int - argv->ex_int <= 0)
+ optr->ex_int = 0;
+ else
+ optr->ex_int = (fts_integer_vector_get_sub_sum(tw, argv->ex_int, argv[1].ex_int) /
+ (argv[1].ex_int - argv->ex_int));
+#endif
+}
+
+/*
+ * ex_store -- store a value in a table
+ * if the index is greater the size of the table,
+ * we will make a modulo the size of the table
+ */
+
+void
+ex_store(t_expr *e, long int argc, struct ex_ex *argv, struct ex_ex *optr)
+{
+/* SDY - look into this function */
+#if 0
+ fts_symbol_t s;
+ fts_integer_vector_t *tw = 0;
+
+ if (argv->ex_type != ET_SYM)
+ {
+ post("expr: store: need a table name\n");
+ }
+
+ s = (fts_symbol_t ) (argv++)->ex_ptr;
+
+ tw = table_integer_vector_get_by_name(s);
+
+ if (! tw)
+ {
+ optr->ex_type = ET_INT;
+ optr->ex_int = 0;
+ post("expr: store: no such table %s\n", fts_symbol_name(s));
+ return;
+ }
+
+ if (argv->ex_type != ET_INT || argv[1].ex_type != ET_INT)
+ {
+ post("expr: store: arguments have to be integer\n");
+ optr->ex_type = ET_INT;
+ optr->ex_int = 0;
+ }
+
+ fts_integer_vector_set_element(tw, argv->ex_int < 0 ? 0 : argv->ex_int % fts_integer_vector_get_size(tw), argv[1].ex_int);
+ *optr = argv[1];
+#endif
+}
+
+#else /* MSP */
+
+void
+pd_error(void *object, char *fmt, ...)
+{
+ va_list ap;
+ t_int arg[8];
+ int i;
+ static int saidit = 0;
+ va_start(ap, fmt);
+/* SDY
+ vsprintf(error_string, fmt, ap);
+ */ post(fmt, ap);
+ va_end(ap);
+/* SDY
+ fprintf(stderr, "error: %s\n", error_string);
+ error_object = object;
+*/
+ if (!saidit)
+ {
+ post("... you might be able to track this down from the Find menu.");
+ saidit = 1;
+ }
+}
+#endif
diff --git a/pd/extra/fiddle~/README.txt b/pd/extra/fiddle~/README.txt
new file mode 100644
index 00000000..82d2ad68
--- /dev/null
+++ b/pd/extra/fiddle~/README.txt
@@ -0,0 +1,33 @@
+Fiddle is copyright (C) 1997 Regents of the University of California.
+Permission is granted to use this software for any noncommercial purpose.
+For commercial licensing contact the UCSD Technology Transfer Office.
+
+UC MAKES NO WARRANTY, EXPRESS OR IMPLIED, IN CONNECTION WITH THIS SOFTWARE!
+
+----------------------------------------------------------------------------
+
+This is the README file for the "fiddle" audio pitch detector. This software
+is available from http://man104nfs.ucsd.edu/~mpuckett in versions for
+IRIX 5.x and for NT on Intel boxes.
+
+Fiddle will soon be available separately for Max/MSP on Macintoshes.
+
+TO INSTALL FOR IRIX 5.x: download from the Web page, which will give you a
+file named "fiddle-x.xx.tar.Z" (where x.xx is the version number). Unpack this
+by typing "zcat fiddle-x.xx.tar.Z | tar xf -" which will give you a directory
+named "fiddle" containing the source, the object code, and the "help patch."
+
+TO INSTALL FOR NT: download from the Web page, which will give you a file
+named "fiddle-x.xx.zip" (where x.xx is the version number). Unpack this by
+typing "unzip fiddle-x.xx.zip" which will give you a directory named "fiddle".
+The source, the object code, and the "help patch" will be there.
+
+Pd currently has no search path facility; the object file (fiddle.pd_irix5 or
+fiddle.dll) should be copied to the directorys containing whatever patches you
+want to use it with.
+
+Please note that the copyright notice on Fiddle is more restrictive than for
+Pd; this is to prevent Fiddle from being incorporated in any commercial product
+that could compete with IRCAM's audio analysis tools.
+
+-Miller Puckette (msp@ucsd.edu)
diff --git a/pd/extra/fiddle~/fiddle~.c b/pd/extra/fiddle~/fiddle~.c
new file mode 100644
index 00000000..373a43eb
--- /dev/null
+++ b/pd/extra/fiddle~/fiddle~.c
@@ -0,0 +1,1818 @@
+/* Copyright (c) 1997-1999 Miller Puckette and Ted Apel.
+* For information on usage and redistribution, and for a DISCLAIMER OF ALL
+* WARRANTIES, see the file, "LICENSE.txt," in this distribution. */
+
+/*
+ * Fiddle is a pitch tracker hardwired to have hop size ("H") equal to
+ * half its window size ("N").
+ *
+ * This version should compile for Max "0.26," JMAX, Pd, or Max/MSP.
+ *
+ * The "lastanalysis" field holds the shifted FT of the previous H
+ * samples. The buffer contains in effect points 1/2, 3/2, ..., (N-1)/2
+ * of the DTFT of a real vector of length N, half of whose points are zero,
+ * i.e., only the first H points are used. Put another way, we get the
+ * the odd-numbered points of the FFT of the H points, zero padded to 4*H in
+ * length. The integer points 0, 1, ..., H-1
+ * are found by interpolating these others, using the fact that the
+ * half-integer points are band-limited (they only have positive frequencies.)
+ * To facilitate the interpolation the "lastanalysis" buffer contains
+ * FILTSIZE extra points (1/2-FILTSIZE, ..., -1/2) at the beginning and
+ * FILTSIZE again at the end ((N+1)/2, ..., FILTSIZE+(N-1)/2). The buffer
+ * therefore has N+4*FILTSIZE floating-point numbers in it.
+ *
+ * after doing this I found out that you can just do a real FFT
+ * of the H new points, zero-padded to contain N points, and using a similar
+ * but simpler interpolation scheme you can still get 2N points of the DTFT
+ * of the N points. Jean Laroche is a big fat hen.
+ *
+ */
+
+#ifdef NT
+#define flog log
+#define fexp exp
+#define fsqrt sqrt
+#pragma warning (disable: 4305 4244)
+#else
+#define flog log
+#define fexp exp
+#define fsqrt sqrt
+#endif
+
+char fiddle_version[] = "fiddle version 1.1 TEST3";
+
+#ifdef JMAX
+#include "fts.h"
+#include <stdio.h>
+#include <stdlib.h>
+typedef float t_float;
+typedef float t_floatarg;
+typedef fts_symbol_t t_symbol;
+
+static void *getbytes(size_t nbytes)
+{
+ void *ret;
+ if (nbytes < 1) nbytes = 1;
+ ret = (void *)malloc(nbytes);
+ return (ret);
+}
+
+static void *resizebytes(void *old, size_t oldsize, size_t newsize)
+{
+ void *ret;
+ if (newsize < 1) newsize = 1;
+ ret = (void *)realloc((char *)old, newsize);
+ return (ret);
+}
+
+static void freebytes(void *fatso, size_t nbytes)
+{
+ free(fatso);
+}
+
+#define CLASSNAME "fiddle"
+
+#define OUTLETpower 5
+#define OUTLETmicropitch1 4
+#define OUTLETmicropitch2 3
+#define OUTLETmicropitch3 2
+#define OUTLETattack 1
+#define OUTLETpitch 0
+
+static fts_symbol_t *dsp_symbol = 0;
+#define error post
+
+#endif /* FTS */
+
+#ifdef MAX26
+#define t_floatarg double
+#include "m_extern.h"
+#include "d_graph.h"
+#include "d_ugen.h"
+#endif /* MAX26 */
+
+#ifdef PD
+#include "m_pd.h"
+#endif /* PD */
+
+#ifdef MSP
+#define flog log
+#define fexp exp
+#define fsqrt sqrt
+#endif /* MSP */
+
+#ifdef MSP
+#define t_floatarg double // this is a guess based on MAX26
+#include "ext.h"
+#include "z_dsp.h"
+#include "fft_mayer.proto.h"
+//#include "fiddle_header.h"
+// #include "MacHeaders.h"
+//#include <MacHeadersPPC>
+
+//#include "fiddledoit.h"
+
+#endif /* MSP */
+
+#include <math.h>
+
+
+#define MINBIN 3
+#define DEFAMPLO 40
+#define DEFAMPHI 50
+#define DEFATTACKTIME 100
+#define DEFATTACKTHRESH 10
+#define DEFVIBTIME 50
+#define DEFVIBDEPTH 0.5
+#define GLISS 0.7f
+#define DBFUDGE 30.8f
+#define MINFREQINBINS 5 /* minimum frequency in bins for reliable output */
+
+#define MAXNPITCH 3
+#define MAXHIST 3 /* find N hottest peaks in histogram */
+
+#define MAXPOINTS 8192
+#define MINPOINTS 128
+#define DEFAULTPOINTS 1024
+
+#define HISTORY 20
+#define MAXPEAK 100 /* maximum number of peaks */
+#define DEFNPEAK 20 /* default number of peaks */
+
+#define MAXNPEAK (MAXLOWPEAK + MAXSTRONGPEAK)
+#define MINBW (0.03f) /* consider BW >= 0.03 FFT bins */
+
+#define BINPEROCT 48 /* bins per octave */
+#define BPERO_OVER_LOG2 69.24936196f /* BINSPEROCT/log(2) */
+#define FACTORTOBINS (float)(4/0.0145453) /* 4 / (pow(2.,1/48.) - 1) */
+#define BINGUARD 10 /* extra bins to throw in front */
+#define PARTIALDEVIANCE 0.023f /* acceptable partial detuning in % */
+#define LOGTODB 4.34294481903f /* 20/log(10) */
+
+#define KNOCKTHRESH 10.f /* don't know how to describe this */
+
+
+static float sigfiddle_partialonset[] =
+{
+0,
+48,
+76.0782000346154967102,
+96,
+111.45254855459339269887,
+124.07820003461549671089,
+134.75303625876499715823,
+144,
+152.15640006923099342109,
+159.45254855459339269887,
+166.05271769459026829915,
+172.07820003461549671088,
+177.62110647077242370064,
+182.75303625876499715892,
+187.53074858920888940907,
+192,
+};
+
+#define NPARTIALONSET ((int)(sizeof(sigfiddle_partialonset)/sizeof(float)))
+
+static int sigfiddle_intpartialonset[] =
+{
+0,
+48,
+76,
+96,
+111,
+124,
+135,
+144,
+152,
+159,
+166,
+172,
+178,
+183,
+188,
+192,
+};
+
+/* these coefficients, which come from the "upsamp" subdirectory,
+are a filter kernel for upsampling by a factor of two, assuming
+the sound to be upsampled has no energy above half the Nyquist, i.e.,
+that it's already 2x oversampled compared to the theoretically possible
+sample rate. I got these by trial and error. */
+
+#define FILT1 ((float)(.5 * 1.227054))
+#define FILT2 ((float)(.5 * -0.302385))
+#define FILT3 ((float)(.5 * 0.095326))
+#define FILT4 ((float)(.5 * -0.022748))
+#define FILT5 ((float)(.5 * 0.002533))
+#define FILTSIZE 5
+
+typedef struct peakout /* a peak for output */
+{
+ float po_freq; /* frequency in hz */
+ float po_amp; /* amplitude */
+} t_peakout;
+
+typedef struct peak /* a peak for analysis */
+{
+ float p_freq; /* frequency in bins */
+ float p_width; /* peak width in bins */
+ float p_pow; /* peak power */
+ float p_loudness; /* 4th root of power */
+ float *p_fp; /* pointer back to spectrum */
+} t_peak;
+
+typedef struct histopeak
+{
+ float h_pitch; /* estimated pitch */
+ float h_value; /* value of peak */
+ float h_loud; /* combined strength of found partials */
+ int h_index; /* index of bin holding peak */
+ int h_used; /* true if an x_hist entry points here */
+} t_histopeak;
+
+typedef struct pitchhist /* struct for keeping history by pitch */
+{
+ float h_pitch; /* pitch to output */
+ float h_amps[HISTORY]; /* past amplitudes */
+ float h_pitches[HISTORY]; /* past pitches */
+ float h_noted; /* last pitch output */
+ int h_age; /* number of frames pitch has been there */
+ t_histopeak *h_wherefrom; /* new histogram peak to incorporate */
+ void *h_outlet;
+} t_pitchhist;
+
+typedef struct sigfiddle /* instance struct */
+{
+#ifdef JMAX
+ fts_object_t x_h; /* object header */
+ fts_alarm_t x_clock; /* callback for timeouts */
+#endif
+#ifdef MAX26
+ t_head x_h; /* header for tilde objects */
+ t_sig *x_io[IN1+OUT0]; /* number of signal inputs and outputs */
+ void *x_clock; /* a "clock" object */
+#endif
+#ifdef PD
+ t_object x_ob; /* object header */
+ t_clock *x_clock; /* callback for timeouts */
+#endif
+#ifdef MSP
+ t_pxobject x_obj;
+ void *x_clock;
+ long x_downsample; // downsample feature because of
+ // MSP's large sig vector sizes
+#endif
+ float *x_inbuf; /* buffer to analyze, npoints/2 elems */
+ float *x_lastanalysis; /* FT of last buffer (see main comment) */
+ float *x_spiral; /* 1/4-wave complex exponential */
+ t_peakout *x_peakbuf; /* spectral peaks for output */
+ int x_npeakout; /* number of spectral peaks to output */
+ int x_npeakanal; /* number of spectral peaks to analyze */
+ int x_phase; /* number of points since last output */
+ int x_histphase; /* phase into amplitude history vector */
+ int x_hop; /* period of output, npoints/2 */
+ float x_sr; /* sample rate */
+ t_pitchhist x_hist[MAXNPITCH]; /* history of current pitches */
+ int x_nprint; /* how many periods to print */
+ int x_npitch; /* number of simultaneous pitches */
+ float x_dbs[HISTORY]; /* DB history, indexed by "histphase" */
+ float x_peaked; /* peak since last attack */
+ int x_dbage; /* number of bins DB has met threshold */
+ int x_auto; /* true if generating continuous output */
+/* parameters */
+ float x_amplo;
+ float x_amphi;
+ int x_attacktime;
+ int x_attackbins;
+ float x_attackthresh;
+ int x_vibtime;
+ int x_vibbins;
+ float x_vibdepth;
+ float x_npartial;
+/* outlets & clock */
+ void *x_envout;
+ int x_attackvalue;
+ void *x_attackout;
+ void *x_noteout;
+ void *x_peakout;
+} t_sigfiddle;
+
+#if CHECKER
+float fiddle_checker[1024];
+#endif
+
+#ifdef MSP
+// Mac compiler requires prototypes for everything
+
+int sigfiddle_ilog2(int n);
+float fiddle_mtof(float f);
+float fiddle_ftom(float f);
+void sigfiddle_doit(t_sigfiddle *x);
+void sigfiddle_debug(t_sigfiddle *x);
+void sigfiddle_print(t_sigfiddle *x);
+void sigfiddle_assist(t_sigfiddle *x, void *b, long m, long a, char *s);
+void sigfiddle_amprange(t_sigfiddle *x, double amplo, double amphi);
+void sigfiddle_reattack(t_sigfiddle *x, t_floatarg attacktime, t_floatarg
+attackthresh);
+void sigfiddle_vibrato(t_sigfiddle *x, t_floatarg vibtime, t_floatarg
+vibdepth);
+void sigfiddle_npartial(t_sigfiddle *x, double npartial);
+void sigfiddle_auto(t_sigfiddle *x, t_floatarg f);
+int sigfiddle_doinit(t_sigfiddle *x, long npoints, long npitch, long
+npeakanal, long npeakout);
+static t_int *fiddle_perform(t_int *w);
+void sigfiddle_dsp(t_sigfiddle *x, t_signal **sp);
+void sigfiddle_tick(t_sigfiddle *x);
+void sigfiddle_bang(t_sigfiddle *x);
+void sigfiddle_ff(t_sigfiddle *x);
+//void *sigfiddle_new(long npoints, long npitch);
+void *sigfiddle_new(long npoints, long npitch,
+ long npeakanal, long npeakout);
+void msp_fft(float *buf, long np, long inv);
+float msp_ffttemp[MAXPOINTS*2];
+int errno;
+#endif
+
+int sigfiddle_ilog2(int n)
+{
+ int ret = -1;
+ while (n)
+ {
+ n >>= 1;
+ ret++;
+ }
+ return (ret);
+}
+
+float fiddle_mtof(float f)
+{
+ return (8.17579891564 * exp(.0577622650 * f));
+}
+
+float fiddle_ftom(float f)
+{
+ return (17.3123405046 * log(.12231220585 * f));
+}
+#define ftom fiddle_ftom
+#define mtof fiddle_mtof
+
+void sigfiddle_doit(t_sigfiddle *x)
+{
+#ifdef MSP
+ // prevents interrupt-level stack overflow crash with Netscape.
+ static float spect1[4*MAXPOINTS];
+ static float spect2[MAXPOINTS + 4*FILTSIZE];
+#else
+ float spect1[4*MAXPOINTS];
+ float spect2[MAXPOINTS + 4*FILTSIZE];
+#endif
+#if CHECKER
+ float checker3[4*MAXPOINTS];
+#endif
+
+ t_peak peaklist[MAXPEAK + 1], *pk1;
+ t_peakout *pk2;
+ t_histopeak histvec[MAXHIST], *hp1;
+ int i, j, k, hop = x->x_hop, n = 2*hop, npeak, npitch,
+ logn = sigfiddle_ilog2(n), newphase, oldphase;
+ float *fp, *fp1, *fp2, *fp3, total_power, total_loudness, total_db;
+ float maxbin = BINPEROCT * (logn-2), *histogram = spect2 + BINGUARD;
+ t_pitchhist *phist;
+ float hzperbin = x->x_sr / (2.0f * n);
+ int npeakout = x->x_npeakout, npeakanal = x->x_npeakanal;
+ int npeaktot = (npeakout > npeakanal ? npeakout : npeakanal);
+
+ oldphase = x->x_histphase;
+ newphase = x->x_histphase + 1;
+ if (newphase == HISTORY) newphase = 0;
+ x->x_histphase = newphase;
+
+ /*
+ * multiply the H points by a 1/4-wave complex exponential,
+ * and take FFT of the result.
+ */
+ for (i = 0, fp1 = x->x_inbuf, fp2 = x->x_spiral, fp3 = spect1;
+ i < hop; i++, fp1++, fp2 += 2, fp3 += 2)
+ fp3[0] = fp1[0] * fp2[0], fp3[1] = fp1[0] * fp2[1];
+
+#ifdef MAX26
+ fft(spect1, hop, 0);
+#endif
+#ifdef PD
+ pd_fft(spect1, hop, 0);
+#endif
+#ifdef JMAX
+ fts_cfft_inplc((complex *)spect1, hop);
+#endif
+#ifdef MSP
+ msp_fft(spect1,hop,0);
+#endif
+ /*
+ * now redistribute the points to get in effect the odd-numbered
+ * points of the FFT of the H points, zero padded to 4*H in length.
+ */
+ for (i = 0, fp1 = spect1, fp2 = spect2 + (2*FILTSIZE);
+ i < (hop>>1); i++, fp1 += 2, fp2 += 4)
+ fp2[0] = fp1[0], fp2[1] = fp1[1];
+ for (i = 0, fp1 = spect1 + n - 2, fp2 = spect2 + (2*FILTSIZE+2);
+ i < (hop>>1); i++, fp1 -= 2, fp2 += 4)
+ fp2[0] = fp1[0], fp2[1] = -fp1[1];
+ for (i = 0, fp1 = spect2 + (2*FILTSIZE), fp2 = spect2 + (2*FILTSIZE-2);
+ i<FILTSIZE; i++, fp1+=2, fp2-=2)
+ fp2[0] = fp1[0], fp2[1] = -fp1[1];
+ for (i = 0, fp1 = spect2 + (2*FILTSIZE+n-2), fp2 = spect2 + (2*FILTSIZE+n);
+ i<FILTSIZE; i++, fp1-=2, fp2+=2)
+ fp2[0] = fp1[0], fp2[1] = -fp1[1];
+#if 0
+ {
+ fp = spect2 + 2*FILTSIZE;
+ post("x1 re %12.4f %12.4f %12.4f %12.4f %12.4f",
+ fp[0], fp[2], fp[4], fp[6], fp[8]);
+ post("x1 im %12.4f %12.4f %12.4f %12.4f %12.4f",
+ fp[1], fp[3], fp[5], fp[7], fp[9]);
+ }
+#endif
+ /* spect2 is now prepared; now combine spect2 and lastanalysis into
+ * spect1. Odd-numbered points of spect1 are the points of "last"
+ * plus (-i, i, -i, ...) times spect1. Even-numbered points are
+ * the interpolated points of "last" plus (1, -1, 1, ...) times the
+ * interpolated points of spect1.
+ *
+ * To interpolate, take FILT1 exp(-pi/4) times
+ * the previous point, FILT2*exp(-3*pi/4) times 3 bins before,
+ * etc, and FILT1 exp(pi/4), FILT2 exp(3pi/4), etc., to weight
+ * the +1, +3, etc., points.
+ *
+ * In this calculation, we take (1, i, -1, -i, 1) times the
+ * -9, -7, ..., -1 points, and (i, -1, -i, 1, i) times the 1, 3,..., 9
+ * points of the OLD spectrum, alternately adding and subtracting
+ * the new spectrum to the old; then we multiply the whole thing
+ * by exp(-i pi/4).
+ */
+ for (i = 0, fp1 = spect1, fp2 = x->x_lastanalysis + 2*FILTSIZE,
+ fp3 = spect2 + 2*FILTSIZE;
+ i < (hop>>1); i++)
+ {
+ float re, im;
+
+ re= FILT1 * ( fp2[ -2] -fp2[ 1] +fp3[ -2] -fp3[ 1]) +
+ FILT2 * ( fp2[ -3] -fp2[ 2] +fp3[ -3] -fp3[ 2]) +
+ FILT3 * (-fp2[ -6] +fp2[ 5] -fp3[ -6] +fp3[ 5]) +
+ FILT4 * (-fp2[ -7] +fp2[ 6] -fp3[ -7] +fp3[ 6]) +
+ FILT5 * ( fp2[-10] -fp2[ 9] +fp3[-10] -fp3[ 9]);
+
+ im= FILT1 * ( fp2[ -1] +fp2[ 0] +fp3[ -1] +fp3[ 0]) +
+ FILT2 * (-fp2[ -4] -fp2[ 3] -fp3[ -4] -fp3[ 3]) +
+ FILT3 * (-fp2[ -5] -fp2[ 4] -fp3[ -5] -fp3[ 4]) +
+ FILT4 * ( fp2[ -8] +fp2[ 7] +fp3[ -8] +fp3[ 7]) +
+ FILT5 * ( fp2[ -9] +fp2[ 8] +fp3[ -9] +fp3[ 8]);
+
+ fp1[0] = 0.7071f * (re + im);
+ fp1[1] = 0.7071f * (im - re);
+ fp1[4] = fp2[0] + fp3[1];
+ fp1[5] = fp2[1] - fp3[0];
+
+ fp1 += 8, fp2 += 2, fp3 += 2;
+ re= FILT1 * ( fp2[ -2] -fp2[ 1] -fp3[ -2] +fp3[ 1]) +
+ FILT2 * ( fp2[ -3] -fp2[ 2] -fp3[ -3] +fp3[ 2]) +
+ FILT3 * (-fp2[ -6] +fp2[ 5] +fp3[ -6] -fp3[ 5]) +
+ FILT4 * (-fp2[ -7] +fp2[ 6] +fp3[ -7] -fp3[ 6]) +
+ FILT5 * ( fp2[-10] -fp2[ 9] -fp3[-10] +fp3[ 9]);
+
+ im= FILT1 * ( fp2[ -1] +fp2[ 0] -fp3[ -1] -fp3[ 0]) +
+ FILT2 * (-fp2[ -4] -fp2[ 3] +fp3[ -4] +fp3[ 3]) +
+ FILT3 * (-fp2[ -5] -fp2[ 4] +fp3[ -5] +fp3[ 4]) +
+ FILT4 * ( fp2[ -8] +fp2[ 7] -fp3[ -8] -fp3[ 7]) +
+ FILT5 * ( fp2[ -9] +fp2[ 8] -fp3[ -9] -fp3[ 8]);
+
+ fp1[0] = 0.7071f * (re + im);
+ fp1[1] = 0.7071f * (im - re);
+ fp1[4] = fp2[0] - fp3[1];
+ fp1[5] = fp2[1] + fp3[0];
+
+ fp1 += 8, fp2 += 2, fp3 += 2;
+ }
+#if 0
+ if (x->x_nprint)
+ {
+ for (i = 0, fp = spect1; i < 16; i++, fp+= 4)
+ post("spect %d %f %f --> %f", i, fp[0], fp[1],
+ sqrt(fp[0] * fp[0] + fp[1] * fp[1]));
+ }
+#endif
+ /* copy new spectrum out */
+ for (i = 0, fp1 = spect2, fp2 = x->x_lastanalysis;
+ i < n + 4*FILTSIZE; i++) *fp2++ = *fp1++;
+
+ for (i = 0; i < MINBIN; i++) spect1[4*i + 2] = spect1[4*i + 3] = 0;
+ /* starting at bin MINBIN, compute hanning windowed power spectrum */
+ for (i = MINBIN, fp1 = spect1+4*MINBIN, total_power = 0;
+ i < n-2; i++, fp1 += 4)
+ {
+ float re = fp1[0] - 0.5f * (fp1[-8] + fp1[8]);
+ float im = fp1[1] - 0.5f * (fp1[-7] + fp1[9]);
+ fp1[3] = (total_power += (fp1[2] = re * re + im * im));
+ }
+
+ if (total_power > 1e-9f)
+ {
+ total_db = (100.f - DBFUDGE) + LOGTODB * log(total_power/n);
+ total_loudness = fsqrt(fsqrt(total_power));
+ if (total_db < 0) total_db = 0;
+ }
+ else total_db = total_loudness = 0;
+ /* store new db in history vector */
+ x->x_dbs[newphase] = total_db;
+ if (total_db < x->x_amplo) goto nopow;
+#if 1
+ if (x->x_nprint) post("power %f", total_power);
+#endif
+
+#if CHECKER
+ /* verify that our FFT resampling thing is putting out good results */
+ for (i = 0; i < hop; i++)
+ {
+ checker3[2*i] = fiddle_checker[i];
+ checker3[2*i + 1] = 0;
+ checker3[n + 2*i] = fiddle_checker[i] = x->x_inbuf[i];
+ checker3[n + 2*i + 1] = 0;
+ }
+ for (i = 2*n; i < 4*n; i++) checker3[i] = 0;
+ fft(checker3, 2*n, 0);
+ if (x->x_nprint)
+ {
+ for (i = 0, fp = checker3; i < 16; i++, fp += 2)
+ post("spect %d %f %f --> %f", i, fp[0], fp[1],
+ sqrt(fp[0] * fp[0] + fp[1] * fp[1]));
+ }
+
+#endif
+ npeak = 0;
+
+ /* search for peaks */
+ for (i = MINBIN, fp = spect1+4*MINBIN, pk1 = peaklist;
+ i < n-2 && npeak < npeaktot; i++, fp += 4)
+ {
+ float height = fp[2], h1 = fp[-2], h2 = fp[6];
+ float totalfreq, pfreq, f1, f2, m, var, stdev;
+
+ if (height < h1 || height < h2 ||
+ h1 < 0.00001f*total_power || h2 < 0.00001f*total_power)
+ continue;
+
+ /* use an informal phase vocoder to estimate the frequency.
+ Do this for the two adjacent bins too. */
+ pfreq= ((fp[-8] - fp[8]) * (2.0f * fp[0] - fp[8] - fp[-8]) +
+ (fp[-7] - fp[9]) * (2.0f * fp[1] - fp[9] - fp[-7])) /
+ (2.0f * height);
+ f1= ((fp[-12] - fp[4]) * (2.0f * fp[-4] - fp[4] - fp[-12]) +
+ (fp[-11] - fp[5]) * (2.0f * fp[-3] - fp[5] - fp[-11])) /
+ (2.0f * h1) - 1;
+ f2= ((fp[-4] - fp[12]) * (2.0f * fp[4] - fp[12] - fp[-4]) +
+ (fp[-3] - fp[13]) * (2.0f * fp[5] - fp[13] - fp[-3])) /
+ (2.0f * h2) + 1;
+
+ /* get sample mean and variance of the three */
+ m = 0.333333f * (pfreq + f1 + f2);
+ var = 0.5f * ((pfreq-m)*(pfreq-m) + (f1-m)*(f1-m) + (f2-m)*(f2-m));
+
+ totalfreq = i + m;
+ if (var * total_power > KNOCKTHRESH * height || var < 1e-30)
+ {
+#if 0
+ if (x->x_nprint)
+ post("cancel: %.2f hz, index %.1f, power %.5f, stdev=%.2f",
+ totalfreq * hzperbin, BPERO_OVER_LOG2 * log(totalfreq) - 96,
+ height, sqrt(var));
+#endif
+ continue;
+ }
+ stdev = fsqrt(var);
+ if (totalfreq < 4)
+ {
+ if (x->x_nprint) post("oops: was %d, freq %f, m %f, stdev %f h %f",
+ i, totalfreq, m, stdev, height);
+ totalfreq = 4;
+ }
+ pk1->p_width = stdev;
+
+ pk1->p_pow = height;
+ pk1->p_loudness = fsqrt(fsqrt(height));
+ pk1->p_fp = fp;
+ pk1->p_freq = totalfreq;
+ npeak++;
+#if 1
+ if (x->x_nprint)
+ {
+ post("peak: %.2f hz. index %.1f, power %.5f, stdev=%.2f",
+ pk1->p_freq * hzperbin,
+ BPERO_OVER_LOG2 * log(pk1->p_freq) - 96,
+ height, stdev);
+ }
+#endif
+ pk1++;
+ }
+
+ /* prepare the raw peaks for output */
+ for (i = 0, pk1 = peaklist, pk2 = x->x_peakbuf; i < npeak;
+ i++, pk1++, pk2++)
+ {
+ float loudness = pk1->p_loudness;
+ if (i >= npeakout) break;
+ pk2->po_freq = hzperbin * pk1->p_freq;
+ pk2->po_amp = (2.f / (float)n) * (loudness * loudness);
+ }
+ for (; i < npeakout; i++, pk2++) pk2->po_amp = pk2->po_freq = 0;
+
+ /* now, working back into spect2, make a sort of "liklihood"
+ * spectrum. Proceeding in 48ths of an octave, from 2 to
+ * n/2 (in bins), the likelihood of each pitch range is contributed
+ * to by every peak in peaklist that's an integer multiple of it
+ * in frequency.
+ */
+
+ if (npeak > npeakanal) npeak = npeakanal; /* max # peaks to analyze */
+ for (i = 0, fp1 = histogram; i < maxbin; i++) *fp1++ = 0;
+ for (i = 0, pk1 = peaklist; i < npeak; i++, pk1++)
+ {
+ float pit = BPERO_OVER_LOG2 * flog(pk1->p_freq) - 96.0f;
+ float binbandwidth = FACTORTOBINS * pk1->p_width/pk1->p_freq;
+ float putbandwidth = (binbandwidth < 2 ? 2 : binbandwidth);
+ float weightbandwidth = (binbandwidth < 1.0f ? 1.0f : binbandwidth);
+ /* float weightamp = 1.0f + 3.0f * pk1->p_pow / pow; */
+ float weightamp = 4. * pk1->p_loudness / total_loudness;
+ for (j = 0, fp2 = sigfiddle_partialonset; j < NPARTIALONSET; j++, fp2++)
+ {
+ float bin = pit - *fp2;
+ if (bin < maxbin)
+ {
+ float para, pphase, score = 30.0f * weightamp /
+ ((j+x->x_npartial) * weightbandwidth);
+ int firstbin = bin + 0.5f - 0.5f * putbandwidth;
+ int lastbin = bin + 0.5f + 0.5f * putbandwidth;
+ int ibw = lastbin - firstbin;
+ if (firstbin < -BINGUARD) break;
+ para = 1.0f / (putbandwidth * putbandwidth);
+ for (k = 0, fp3 = histogram + firstbin,
+ pphase = firstbin-bin; k <= ibw;
+ k++, fp3++, pphase += 1.0f)
+ {
+ *fp3 += score * (1.0f - para * pphase * pphase);
+ }
+ }
+ }
+ }
+#if 1
+ if (x->x_nprint)
+ {
+ for (i = 0; i < 6*5; i++)
+ {
+ float fhz = hzperbin * exp ((8*i + 96) * (1./BPERO_OVER_LOG2));
+ if (!(i % 6)) post("-- bin %d pitch %f freq %f----", 8*i,
+ ftom(fhz), fhz);;
+ post("%3d %3d %3d %3d %3d %3d %3d %3d",
+ (int)(histogram[8*i]),
+ (int)(histogram[8*i+1]),
+ (int)(histogram[8*i+2]),
+ (int)(histogram[8*i+3]),
+ (int)(histogram[8*i+4]),
+ (int)(histogram[8*i+5]),
+ (int)(histogram[8*i+6]),
+ (int)(histogram[8*i+7]));
+ }
+ }
+
+#endif
+
+ /*
+ * Next we find up to NPITCH strongest peaks in the histogram.
+ * if a peak is related to a stronger one via an interval in
+ * the sigfiddle_partialonset array, we suppress it.
+ */
+
+ for (npitch = 0; npitch < x->x_npitch; npitch++)
+ {
+ int index;
+ float best;
+ if (npitch)
+ {
+ for (best = 0, index = -1, j=1; j < maxbin-1; j++)
+ {
+ if (histogram[j] > best && histogram[j] > histogram[j-1] &&
+ histogram[j] > histogram[j+1])
+ {
+ for (k = 0; k < npitch; k++)
+ if (histvec[k].h_index == j)
+ goto peaknogood;
+ for (k = 0; k < NPARTIALONSET; k++)
+ {
+ if (j - sigfiddle_intpartialonset[k] < 0) break;
+ if (histogram[j - sigfiddle_intpartialonset[k]]
+ > histogram[j]) goto peaknogood;
+ }
+ for (k = 0; k < NPARTIALONSET; k++)
+ {
+ if (j + sigfiddle_intpartialonset[k] >= maxbin) break;
+ if (histogram[j + sigfiddle_intpartialonset[k]]
+ > histogram[j]) goto peaknogood;
+ }
+ index = j;
+ best = histogram[j];
+ }
+ peaknogood: ;
+ }
+ }
+ else
+ {
+ for (best = 0, index = -1, j=0; j < maxbin; j++)
+ if (histogram[j] > best)
+ index = j, best = histogram[j];
+ }
+ if (index < 0) break;
+ histvec[npitch].h_value = best;
+ histvec[npitch].h_index = index;
+ }
+#if 1
+ if (x->x_nprint)
+ {
+ for (i = 0; i < npitch; i++)
+ {
+ post("index %d freq %f --> value %f", histvec[i].h_index,
+ exp((1./BPERO_OVER_LOG2) * (histvec[i].h_index + 96)),
+ histvec[i].h_value);
+ post("next %f , prev %f",
+ exp((1./BPERO_OVER_LOG2) * (histvec[i].h_index + 97)),
+ exp((1./BPERO_OVER_LOG2) * (histvec[i].h_index + 95)) );
+ }
+ }
+#endif
+
+ /* for each histogram peak, we now search back through the
+ * FFT peaks. A peak is a pitch if either there are several
+ * harmonics that match it, or else if (a) the fundamental is
+ * present, and (b) the sum of the powers of the contributing peaks
+ * is at least 1/100 of the total power.
+ *
+ * A peak is a contributor if its frequency is within 25 cents of
+ * a partial from 1 to 16.
+ *
+ * Finally, we have to be at least 5 bins in frequency, which
+ * corresponds to 2-1/5 periods fitting in the analysis window.
+ */
+
+ for (i = 0; i < npitch; i++)
+ {
+ float cumpow = 0, cumstrength = 0, freqnum = 0, freqden = 0;
+ int npartials = 0, nbelow8 = 0;
+ /* guessed-at frequency in bins */
+ float putfreq = fexp((1.0f / BPERO_OVER_LOG2) *
+ (histvec[i].h_index + 96.0f));
+ for (j = 0; j < npeak; j++)
+ {
+ float fpnum = peaklist[j].p_freq/putfreq;
+ int pnum = fpnum + 0.5f;
+ float fipnum = pnum;
+ float deviation;
+ if (pnum > 16 || pnum < 1) continue;
+ deviation = 1.0f - fpnum/fipnum;
+ if (deviation > -PARTIALDEVIANCE && deviation < PARTIALDEVIANCE)
+ {
+ /*
+ * we figure this is a partial since it's within 1/4 of
+ * a halftone of a multiple of the putative frequency.
+ */
+
+ float stdev, weight;
+ npartials++;
+ if (pnum < 8) nbelow8++;
+ cumpow += peaklist[j].p_pow;
+ cumstrength += fsqrt(fsqrt(peaklist[j].p_pow));
+ stdev = (peaklist[j].p_width > MINBW ?
+ peaklist[j].p_width : MINBW);
+ weight = 1.0f / ((stdev*fipnum) * (stdev*fipnum));
+ freqden += weight;
+ freqnum += weight * peaklist[j].p_freq/fipnum;
+#if 1
+ if (x->x_nprint)
+ {
+ post("peak %d partial %d f=%f w=%f",
+ j, pnum, peaklist[j].p_freq/fipnum, weight);
+ }
+#endif
+ }
+#if 1
+ else if (x->x_nprint) post("peak %d partial %d dev %f",
+ j, pnum, deviation);
+#endif
+ }
+ if ((nbelow8 < 4 || npartials < 7) && cumpow < 0.01f * total_power)
+ histvec[i].h_value = 0;
+ else
+ {
+ float pitchpow = (cumstrength * cumstrength) *
+ (cumstrength * cumstrength);
+ float freqinbins = freqnum/freqden;
+ /* check for minimum output frequency */
+
+ if (freqinbins < MINFREQINBINS)
+ histvec[i].h_value = 0;
+ else
+ {
+ /* we passed all tests... save the values we got */
+ histvec[i].h_pitch = ftom(hzperbin * freqnum/freqden);
+ histvec[i].h_loud = (100.0f -DBFUDGE) +
+ (LOGTODB) * log(pitchpow/n);
+ }
+ }
+ }
+#if 1
+ if (x->x_nprint)
+ {
+ for (i = 0; i < npitch; i++)
+ {
+ if (histvec[i].h_value > 0)
+ post("index %d pit %f loud %f", histvec[i].h_index,
+ histvec[i].h_pitch, histvec[i].h_loud);
+ else post("-- cancelled --");
+ }
+ }
+#endif
+
+ /* now try to find continuous pitch tracks that match the new
+ * pitches. First mark each peak unmatched.
+ */
+ for (i = 0, hp1 = histvec; i < npitch; i++, hp1++)
+ hp1->h_used = 0;
+
+ /* for each old pitch, try to match a new one to it. */
+ for (i = 0, phist = x->x_hist; i < x->x_npitch; i++, phist++)
+ {
+ float thispitch = phist->h_pitches[oldphase];
+ phist->h_pitch = 0; /* no output, thanks */
+ phist->h_wherefrom = 0;
+ if (thispitch == 0.0f) continue;
+ for (j = 0, hp1 = histvec; j < npitch; j++, hp1++)
+ if ((hp1->h_value > 0) && hp1->h_pitch > thispitch - GLISS
+ && hp1->h_pitch < thispitch + GLISS)
+ {
+ phist->h_wherefrom = hp1;
+ hp1->h_used = 1;
+ }
+ }
+ for (i = 0, hp1 = histvec; i < npitch; i++, hp1++)
+ if ((hp1->h_value > 0) && !hp1->h_used)
+ {
+ for (j = 0, phist = x->x_hist; j < x->x_npitch; j++, phist++)
+ if (!phist->h_wherefrom)
+ {
+ phist->h_wherefrom = hp1;
+ phist->h_age = 0;
+ phist->h_noted = 0;
+ hp1->h_used = 1;
+ goto happy;
+ }
+ break;
+ happy: ;
+ }
+ /* copy the pitch info into the history vector */
+ for (i = 0, phist = x->x_hist; i < x->x_npitch; i++, phist++)
+ {
+ if (phist->h_wherefrom)
+ {
+ phist->h_amps[newphase] = phist->h_wherefrom->h_loud;
+ phist->h_pitches[newphase] =
+ phist->h_wherefrom->h_pitch;
+ (phist->h_age)++;
+ }
+ else
+ {
+ phist->h_age = 0;
+ phist->h_amps[newphase] = phist->h_pitches[newphase] = 0;
+ }
+ }
+#if 1
+ if (x->x_nprint)
+ {
+ post("vibrato %d %f", x->x_vibbins, x->x_vibdepth);
+ for (i = 0, phist = x->x_hist; i < x->x_npitch; i++, phist++)
+ {
+ post("noted %f, age %d", phist->h_noted, phist->h_age);
+#ifndef I860
+ post("values %f %f %f %f %f",
+ phist->h_pitches[newphase],
+ phist->h_pitches[(newphase + HISTORY-1)%HISTORY],
+ phist->h_pitches[(newphase + HISTORY-2)%HISTORY],
+ phist->h_pitches[(newphase + HISTORY-3)%HISTORY],
+ phist->h_pitches[(newphase + HISTORY-4)%HISTORY]);
+#endif
+ }
+ }
+#endif
+ /* look for envelope attacks */
+
+ x->x_attackvalue = 0;
+
+ if (x->x_peaked)
+ {
+ if (total_db > x->x_amphi)
+ {
+ int binlook = newphase - x->x_attackbins;
+ if (binlook < 0) binlook += HISTORY;
+ if (total_db > x->x_dbs[binlook] + x->x_attackthresh)
+ {
+ x->x_attackvalue = 1;
+ x->x_peaked = 0;
+ }
+ }
+ }
+ else
+ {
+ int binlook = newphase - x->x_attackbins;
+ if (binlook < 0) binlook += HISTORY;
+ if (x->x_dbs[binlook] > x->x_amphi && x->x_dbs[binlook] > total_db)
+ x->x_peaked = 1;
+ }
+
+ /* for each current frequency track, test for a new note using a
+ * stability criterion. Later perhaps we should also do as in
+ * pitch~ and check for unstable notes a posteriori when
+ * there's a new attack with no note found since the last onset;
+ * but what's an attack &/or onset when we're polyphonic?
+ */
+
+ for (i = 0, phist = x->x_hist; i < x->x_npitch; i++, phist++)
+ {
+ /*
+ * if we've found a pitch but we've now strayed from it turn
+ * it off.
+ */
+ if (phist->h_noted)
+ {
+ if (phist->h_pitches[newphase] > phist->h_noted + x->x_vibdepth
+ || phist->h_pitches[newphase] < phist->h_noted - x->x_vibdepth)
+ phist->h_noted = 0;
+ }
+ else
+ {
+ if (phist->h_wherefrom && phist->h_age >= x->x_vibbins)
+ {
+ float centroid = 0;
+ int not = 0;
+ for (j = 0, k = newphase; j < x->x_vibbins; j++)
+ {
+ centroid += phist->h_pitches[k];
+ k--;
+ if (k < 0) k = HISTORY-1;
+ }
+ centroid /= x->x_vibbins;
+ for (j = 0, k = newphase; j < x->x_vibbins; j++)
+ {
+ /* calculate deviation from norm */
+ float dev = centroid - phist->h_pitches[k];
+ k--;
+ if (k < 0) k = HISTORY-1;
+ if (dev > x->x_vibdepth ||
+ -dev > x->x_vibdepth) not = 1;
+ }
+ if (!not)
+ {
+ phist->h_pitch = phist->h_noted = centroid;
+ }
+ }
+ }
+ }
+ return;
+
+nopow:
+ for (i = 0; i < x->x_npitch; i++)
+ {
+ x->x_hist[i].h_pitch = x->x_hist[i].h_noted =
+ x->x_hist[i].h_pitches[newphase] =
+ x->x_hist[i].h_amps[newphase] = 0;
+ x->x_hist[i].h_age = 0;
+ }
+ x->x_peaked = 1;
+ x->x_dbage = 0;
+}
+
+void sigfiddle_debug(t_sigfiddle *x)
+{
+ x->x_nprint = 1;
+}
+
+void sigfiddle_print(t_sigfiddle *x)
+{
+ post("amp-range %f %f,", x->x_amplo, x->x_amphi);
+ post("reattack %d %f,", x->x_attacktime, x->x_attackthresh);
+ post("vibrato %d %f", x->x_vibtime, x->x_vibdepth);
+ post("npartial %f", x->x_npartial);
+ post("auto %d", x->x_auto);
+}
+
+void sigfiddle_amprange(t_sigfiddle *x, t_floatarg amplo, t_floatarg amphi)
+{
+ if (amplo < 0) amplo = 0;
+ if (amphi < amplo) amphi = amplo + 1;
+ x->x_amplo = amplo;
+ x->x_amphi = amphi;
+}
+
+void sigfiddle_reattack(t_sigfiddle *x,
+ t_floatarg attacktime, t_floatarg attackthresh)
+{
+ if (attacktime < 0) attacktime = 0;
+ if (attackthresh <= 0) attackthresh = 1000;
+ x->x_attacktime = attacktime;
+ x->x_attackthresh = attackthresh;
+ x->x_attackbins = (x->x_sr * 0.001 * attacktime) / x->x_hop;
+ if (x->x_attackbins >= HISTORY) x->x_attackbins = HISTORY - 1;
+}
+
+void sigfiddle_vibrato(t_sigfiddle *x, t_floatarg vibtime, t_floatarg vibdepth)
+{
+ if (vibtime < 0) vibtime = 0;
+ if (vibdepth <= 0) vibdepth = 1000;
+ x->x_vibtime = vibtime;
+ x->x_vibdepth = vibdepth;
+ x->x_vibbins = (x->x_sr * 0.001 * vibtime) / x->x_hop;
+ if (x->x_vibbins >= HISTORY) x->x_vibbins = HISTORY - 1;
+ if (x->x_vibbins < 1) x->x_vibbins = 1;
+}
+
+void sigfiddle_npartial(t_sigfiddle *x, t_floatarg npartial)
+{
+ if (npartial < 0.1) npartial = 0.1;
+ x->x_npartial = npartial;
+}
+
+void sigfiddle_auto(t_sigfiddle *x, t_floatarg f)
+{
+ x->x_auto = (f != 0);
+}
+
+int sigfiddle_doinit(t_sigfiddle *x, long npoints, long npitch,
+ long npeakanal, long npeakout)
+{
+ float *buf1, *buf2, *buf3;
+ t_peakout *buf4;
+ int i, hop;
+
+ if (npoints < MINPOINTS || npoints > MAXPOINTS) npoints = DEFAULTPOINTS;
+ npoints = 1 << sigfiddle_ilog2(npoints);
+ hop = npoints>>1;
+ if (!npeakanal && !npeakout) npeakanal = DEFNPEAK, npeakout = 0;
+ if (!npeakanal < 0) npeakanal = 0;
+ else if (npeakanal > MAXPEAK) npeakanal = MAXPEAK;
+ if (!npeakout < 0) npeakout = 0;
+ else if (npeakout > MAXPEAK) npeakout = MAXPEAK;
+ if (npitch <= 0) npitch = 0;
+ else if (npitch > MAXNPITCH) npitch = MAXNPITCH;
+ if (npeakanal && !npitch) npitch = 1;
+
+
+ if (!(buf1 = (float *)getbytes(sizeof(float) * hop)))
+ {
+ error("fiddle~: out of memory");
+ return (0);
+ }
+ if (!(buf2 = (float *)getbytes(sizeof(float) * (npoints + 4 * FILTSIZE))))
+ {
+ freebytes(buf1, sizeof(float) * hop);
+ error("fiddle~: out of memory");
+ return (0);
+ }
+ if (!(buf3 = (float *)getbytes(sizeof(float) * npoints)))
+ {
+ freebytes(buf1, sizeof(float) * hop);
+ freebytes(buf2, sizeof(float) * (npoints + 4 * FILTSIZE));
+ error("fiddle~: out of memory");
+ return (0);
+ }
+ if (!(buf4 = (t_peakout *)getbytes(sizeof(*buf4) * npeakout)))
+ {
+ freebytes(buf1, sizeof(float) * hop);
+ freebytes(buf2, sizeof(float) * (npoints + 4 * FILTSIZE));
+ freebytes(buf3, sizeof(float) * npoints);
+ error("fiddle~: out of memory");
+ return (0);
+ }
+ for (i = 0; i < hop; i++) buf1[i] = 0;
+ for (i = 0; i < npoints + 4 * FILTSIZE; i++) buf2[i] = 0;
+ for (i = 0; i < hop; i++)
+ buf3[2*i] = cos((3.14159*i)/(npoints)),
+ buf3[2*i+1] = -sin((3.14159*i)/(npoints));
+ for (i = 0; i < npeakout; i++)
+ buf4[i].po_freq = buf4[i].po_amp = 0;
+ x->x_inbuf = buf1;
+ x->x_lastanalysis = buf2;
+ x->x_spiral = buf3;
+ x->x_peakbuf = buf4;
+
+ x->x_npeakout = npeakout;
+ x->x_npeakanal = npeakanal;
+ x->x_phase = 0;
+ x->x_histphase = 0;
+ x->x_hop = npoints>>1;
+ x->x_sr = 44100; /* this and the next are filled in later */
+ for (i = 0; i < MAXNPITCH; i++)
+ {
+ int j;
+ x->x_hist[i].h_pitch = x->x_hist[i].h_noted = 0;
+ x->x_hist[i].h_age = 0;
+ x->x_hist[i].h_wherefrom = 0;
+ x->x_hist[i].h_outlet = 0;
+ for (j = 0; j < HISTORY; j++)
+ x->x_hist[i].h_amps[j] = x->x_hist[i].h_pitches[j] = 0;
+ }
+ x->x_nprint = 0;
+ x->x_npitch = npitch;
+ for (i = 0; i < HISTORY; i++) x->x_dbs[i] = 0;
+ x->x_dbage = 0;
+ x->x_peaked = 0;
+ x->x_auto = 1;
+ x->x_amplo = DEFAMPLO;
+ x->x_amphi = DEFAMPHI;
+ x->x_attacktime = DEFATTACKTIME;
+ x->x_attackbins = 1; /* real value calculated afterward */
+ x->x_attackthresh = DEFATTACKTHRESH;
+ x->x_vibtime = DEFVIBTIME;
+ x->x_vibbins = 1; /* real value calculated afterward */
+ x->x_vibdepth = DEFVIBDEPTH;
+ x->x_npartial = 7;
+ x->x_attackvalue = 0;
+ return (1);
+}
+
+ /* formalities for JMAX */
+
+#ifdef JMAX
+
+void sigfiddle_debug13(fts_object_t *o, int winlet, fts_symbol_t s, int ac, const fts_atom_t *at)
+{
+ t_sigfiddle *x = (t_sigfiddle *)o;
+ sigfiddle_debug(x);
+}
+
+void sigfiddle_print13(fts_object_t *o, int winlet, fts_symbol_t s,
+ int ac, const fts_atom_t *at)
+{
+ t_sigfiddle *x = (t_sigfiddle *)o;
+ sigfiddle_print(x);
+}
+
+void sigfiddle_amprange13(fts_object_t *o, int winlet, fts_symbol_t s,
+ int ac, const fts_atom_t *at)
+{
+ t_sigfiddle *x = (t_sigfiddle *)o;
+ float lo = (float) fts_get_float_arg(ac, at, 0, 0);
+ float hi = (float) fts_get_float_arg(ac, at, 1, 0);
+ sigfiddle_amprange(x, lo, hi);
+}
+
+void sigfiddle_reattack13(fts_object_t *o, int winlet, fts_symbol_t s,
+ int ac, const fts_atom_t *at)
+{
+ t_sigfiddle *x = (t_sigfiddle *)o;
+ long msec = fts_get_float_arg(ac, at, 0, 0);
+ float db = (float) fts_get_float_arg(ac, at, 1, 0);
+ sigfiddle_reattack(x, msec, db);
+}
+
+void sigfiddle_vibrato13(fts_object_t *o, int winlet, fts_symbol_t s,
+ int ac, const fts_atom_t *at)
+{
+ t_sigfiddle *x = (t_sigfiddle *)o;
+ long msec = fts_get_float_arg(ac, at, 0, 0);
+ float halftones = (float) fts_get_float_arg(ac, at, 1, 0);
+ sigfiddle_vibrato(x, msec, halftones);
+}
+
+void sigfiddle_npartial13(fts_object_t *o, int winlet, fts_symbol_t s,
+ int ac, const fts_atom_t *at)
+{
+ t_sigfiddle *x = (t_sigfiddle *)o;
+ float npartial = (float) fts_get_float_arg(ac, at, 0, 0);
+ sigfiddle_npartial(x, npartial);
+}
+
+
+void ftl_sigfiddle(fts_word_t *a)
+{
+ t_sigfiddle *x = (t_sigfiddle *)fts_word_get_long(a);
+ float *in = (float *)fts_word_get_long(a + 1);
+ long n_tick = fts_word_get_long(a + 2);
+
+ int count;
+ float *fp, *fp2;
+ for (count = 0, fp = x->x_inbuf + x->x_phase;
+ count < n_tick; count++) *fp++ = *in++;
+ if (fp == x->x_inbuf + x->x_hop)
+ {
+ sigfiddle_doit(x);
+ x->x_phase = 0;
+ fts_alarm_set_delay(&x->x_clock, 0L); /* output bang */
+ fts_alarm_arm(&x->x_clock);
+
+ if (x->x_nprint) x->x_nprint--;
+ }
+ else x->x_phase += n_tick;
+}
+
+void sigfiddle_put(fts_object_t *o, int winlet, fts_symbol_t *s, int ac, const fts_atom_t *at)
+{
+ t_sigfiddle *x = (t_sigfiddle *)o;
+ fts_dsp_descr_t *dsp = (fts_dsp_descr_t *)fts_get_long_arg(ac, at, 0, 0);
+ fts_atom_t a[3];
+
+ x->x_sr = fts_dsp_get_input_srate(dsp, 0);
+ sigfiddle_reattack(x, x->x_attacktime, x->x_attackthresh);
+ sigfiddle_vibrato(x, x->x_vibtime, x->x_vibdepth);
+
+ fts_set_long(a, (long)x);
+ fts_set_symbol(a+1, fts_dsp_get_input_name(dsp, 0));
+ fts_set_long(a+2, fts_dsp_get_input_size(dsp, 0));
+ dsp_add_funcall(dsp_symbol, 3, a);
+}
+
+void sigfiddle_tick(fts_alarm_t *alarm, void *p)
+{
+ fts_object_t *o = (fts_object_t *)p;
+ t_sigfiddle *x = (t_sigfiddle *)p;
+
+ int i;
+ t_pitchhist *ph;
+ fts_outlet_float(o, OUTLETpower, x->x_dbs[x->x_histphase]);
+ for (i = 0, ph = x->x_hist; i < x->x_npitch; i++, ph++)
+ {
+ fts_atom_t at[2];
+ fts_set_float(at, ph->h_pitches[x->x_histphase]);
+ fts_set_float(at+1, ph->h_amps[x->x_histphase]);
+ fts_outlet_list(o, OUTLETmicropitch3 - i, 2, at);
+ }
+ if (x->x_attackvalue) fts_outlet_bang(o, OUTLETattack);
+ for (i = 0, ph = x->x_hist; i < x->x_npitch; i++, ph++)
+ if (ph->h_pitch) fts_outlet_float(o, OUTLETpitch, ph->h_pitch);
+}
+
+static void sigfiddle_delete(fts_object_t *o, int winlet, fts_symbol_t *s, int ac,
+ const fts_atom_t *at)
+{
+ t_sigfiddle *x = (t_sigfiddle *)o;
+
+ fts_free(x->x_inbuf);
+ fts_free(x->x_lastanalysis);
+ fts_free(x->x_spiral);
+ dsp_list_remove(o);
+}
+
+static void sigfiddle_init(fts_object_t *o, int winlet, fts_symbol_t *s, int ac, const fts_atom_t *at)
+{
+ t_sigfiddle *x = (t_sigfiddle *)o;
+ float *buf1, *buf2, *buf3;
+ int i, hop;
+ long npoints = fts_get_long_arg(ac, at, 1, 0);
+ long npitch = fts_get_long_arg(ac, at, 2, 0);
+ long npeakanal = fts_get_long_arg(ac, at, 3, 0);
+ long npeakout = fts_get_long_arg(ac, at, 4, 0);
+
+ if (!sigfiddle_doinit(x, npoints, npitch, npeakanal, npeakout))
+ {
+ post("fiddle~: initialization failed");
+ return;
+ }
+ hop = npoints>>1;
+ if (fts_fft_declaresize(hop) != fts_Success)
+ post("fiddle~: bad FFT size");
+
+ fts_alarm_init(&(x->x_clock), 0, sigfiddle_tick, x);
+ dsp_list_insert(o);
+}
+
+static fts_status_t sigfiddle_instantiate(fts_class_t *cl, int ac,
+ const fts_atom_t *at)
+{
+ int i;
+ fts_type_t a[5];
+
+ fts_class_init(cl, sizeof(t_sigfiddle), 1, 6, 0); /* 1 inlet + 6 outlets */
+
+ /* the system methods */
+
+ a[0] = fts_Symbol;
+ a[1] = fts_Long | fts_OptArg;
+ a[2] = fts_Long | fts_OptArg;
+ fts_method_define(cl, fts_SystemInlet, fts_s_init, sigfiddle_init, 3, a);
+
+ fts_method_define(cl, fts_SystemInlet, fts_s_delete, sigfiddle_delete, 0, a);
+ a[0] = fts_Object;
+ fts_method_define(cl, fts_SystemInlet, fts_s_put, sigfiddle_put, 1, a);
+
+ /* class' own methods */
+ fts_method_define(cl, 0, fts_new_symbol("print"), sigfiddle_print13, 0, a);
+ fts_method_define(cl, 0, fts_new_symbol("debug"), sigfiddle_debug13, 0, a);
+ fts_method_define(cl, 0, fts_new_symbol("amp-range"), sigfiddle_amprange13,
+ 0, a);
+ fts_method_define(cl, 0, fts_new_symbol("reattack"), sigfiddle_reattack13,
+ 0, a);
+ fts_method_define(cl, 0, fts_new_symbol("vibrato"), sigfiddle_vibrato13,
+ 0, a);
+ fts_method_define(cl, 0, fts_new_symbol("npartial"), sigfiddle_npartial13,
+ 0, a);
+
+ /* classes signal inlets */
+ dsp_sig_inlet(cl, 0); /* declare signal input #0 */
+
+ /* classes outlets */
+ a[0] = fts_Float;
+ fts_outlet_type_define(cl, OUTLETpitch, fts_s_float, 1, a); /* declare outlet #0 */
+ fts_outlet_type_define(cl, OUTLETattack, fts_s_bang, 0, a); /* declare outlet #1 */
+ a[0] = fts_VarArgs;
+ fts_outlet_type_define(cl, OUTLETmicropitch1, fts_s_list, 1, a); /* declare outlet #2 */
+ fts_outlet_type_define(cl, OUTLETmicropitch2, fts_s_list, 1, a); /* declare outlet #3 */
+ fts_outlet_type_define(cl, OUTLETmicropitch3, fts_s_list, 1, a); /* declare outlet #4 */
+ a[0] = fts_Float;
+ fts_outlet_type_define(cl, OUTLETpower, fts_s_float, 1, a); /* declare outlet #5 */
+
+ dsp_symbol = fts_new_symbol("fiddle");
+ dsp_declare_function(dsp_symbol, ftl_sigfiddle);
+
+ /* DSP properties */
+
+ fts_class_put_prop(cl, fts_s_dsp_is_sink, fts_true);
+
+ return(fts_Success);
+}
+
+void fiddle_config(void)
+{
+ sys_log(fiddle_version);
+ fts_metaclass_create(fts_new_symbol(CLASSNAME), sigfiddle_instantiate, fts_always_equiv);
+}
+
+fts_module_t fiddle_module =
+ {"fiddle", "sonic meat fiddle", fiddle_config, 0};
+
+#endif /* JMAX */
+
+#ifdef PD
+
+static t_int *fiddle_perform(t_int *w)
+{
+ t_float *in = (t_float *)(w[1]);
+ t_sigfiddle *x = (t_sigfiddle *)(w[2]);
+ int n = (int)(w[3]);
+ int count;
+ float *fp;
+ for (count = 0, fp = x->x_inbuf + x->x_phase; count < n; count++)
+ *fp++ = *in++;
+ if (fp == x->x_inbuf + x->x_hop)
+ {
+ sigfiddle_doit(x);
+ x->x_phase = 0;
+ if (x->x_auto) clock_delay(x->x_clock, 0L);
+ if (x->x_nprint) x->x_nprint--;
+ }
+ else x->x_phase += n;
+ return (w+4);
+}
+
+void sigfiddle_dsp(t_sigfiddle *x, t_signal **sp)
+{
+ x->x_sr = sp[0]->s_sr;
+ sigfiddle_reattack(x, x->x_attacktime, x->x_attackthresh);
+ sigfiddle_vibrato(x, x->x_vibtime, x->x_vibdepth);
+ dsp_add(fiddle_perform, 3, sp[0]->s_vec, x, sp[0]->s_n);
+}
+
+ /* This is the callback function for the clock, but also acts as
+ the "bang" method; you can leave "auto" on to get this called
+ automatically (the default) or turn auto off and bang it yourself. */
+
+void sigfiddle_bang(t_sigfiddle *x)
+{
+ int i;
+ t_pitchhist *ph;
+ if (x->x_npeakout)
+ {
+ int npeakout = x->x_npeakout;
+ t_peakout *po;
+ for (i = 0, po = x->x_peakbuf; i < npeakout; i++, po++)
+ {
+ t_atom at[3];
+ SETFLOAT(at, i+1);
+ SETFLOAT(at+1, po->po_freq);
+ SETFLOAT(at+2, po->po_amp);
+ outlet_list(x->x_peakout, 0, 3, at);
+ }
+ }
+ outlet_float(x->x_envout, x->x_dbs[x->x_histphase]);
+ for (i = 0, ph = x->x_hist; i < x->x_npitch; i++, ph++)
+ {
+ t_atom at[2];
+ SETFLOAT(at, ph->h_pitches[x->x_histphase]);
+ SETFLOAT(at+1, ph->h_amps[x->x_histphase]);
+ outlet_list(ph->h_outlet, 0, 2, at);
+ }
+ if (x->x_attackvalue) outlet_bang(x->x_attackout);
+ for (i = 0, ph = x->x_hist; i < x->x_npitch; i++, ph++)
+ if (ph->h_pitch) outlet_float(x->x_noteout, ph->h_pitch);
+}
+
+void sigfiddle_ff(t_sigfiddle *x) /* cleanup on free */
+{
+ if (x->x_inbuf)
+ {
+ freebytes(x->x_inbuf, sizeof(float) * x->x_hop);
+ freebytes(x->x_lastanalysis, sizeof(float) * (2*x->x_hop + 4 * FILTSIZE));
+ freebytes(x->x_spiral, sizeof(float) * 2*x->x_hop);
+ freebytes(x->x_peakbuf, sizeof(*x->x_peakbuf) * x->x_npeakout);
+ clock_free(x->x_clock);
+ }
+}
+
+static t_class *sigfiddle_class;
+
+void *sigfiddle_new(t_floatarg npoints, t_floatarg npitch,
+ t_floatarg fnpeakanal, t_floatarg fnpeakout)
+{
+ t_sigfiddle *x = (t_sigfiddle *)pd_new(sigfiddle_class);
+ int i;
+ int npeakanal = fnpeakanal, npeakout = fnpeakout;
+
+
+ if (!sigfiddle_doinit(x, npoints, npitch,
+ npeakanal, npeakout))
+ {
+ x->x_inbuf = 0; /* prevent the free routine from cleaning up */
+ pd_free(&x->x_ob.ob_pd);
+ return (0);
+ }
+ x->x_noteout = outlet_new(&x->x_ob, gensym("float"));
+ x->x_attackout = outlet_new(&x->x_ob, gensym("bang"));
+ for (i = 0; i < x->x_npitch; i++)
+ x->x_hist[i].h_outlet = outlet_new(&x->x_ob, gensym("list"));
+ x->x_envout = outlet_new(&x->x_ob, gensym("float"));
+ if (x->x_npeakout)
+ x->x_peakout = outlet_new(&x->x_ob, gensym("list"));
+ else x->x_peakout = 0;
+ x->x_clock = clock_new(&x->x_ob.ob_pd, (t_method)sigfiddle_bang);
+ return (x);
+}
+
+void fiddle_tilde_setup(void)
+{
+ sigfiddle_class = class_new(gensym("fiddle~"), (t_newmethod)sigfiddle_new,
+ (t_method)sigfiddle_ff, sizeof(t_sigfiddle), 0,
+ A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0);
+ class_addmethod(sigfiddle_class, (t_method)sigfiddle_dsp,
+ gensym("dsp"), 0);
+ class_addmethod(sigfiddle_class, (t_method)sigfiddle_debug,
+ gensym("debug"), 0);
+ class_addmethod(sigfiddle_class, (t_method)sigfiddle_amprange,
+ gensym("amp-range"), A_FLOAT, A_FLOAT, 0);
+ class_addmethod(sigfiddle_class, (t_method)sigfiddle_reattack,
+ gensym("reattack"), A_FLOAT, A_FLOAT, 0);
+ class_addmethod(sigfiddle_class, (t_method)sigfiddle_vibrato,
+ gensym("vibrato"), A_FLOAT, A_FLOAT, 0);
+ class_addmethod(sigfiddle_class, (t_method)sigfiddle_npartial,
+ gensym("npartial"), A_FLOAT, 0);
+ class_addmethod(sigfiddle_class, (t_method)sigfiddle_auto,
+ gensym("auto"), A_FLOAT, 0);
+ class_addmethod(sigfiddle_class, (t_method)sigfiddle_print,
+ gensym("print"), 0);
+ class_addmethod(sigfiddle_class, nullfn, gensym("signal"), 0);
+ class_addbang(sigfiddle_class, sigfiddle_bang);
+ class_addcreator((t_newmethod)sigfiddle_new, gensym("fiddle"),
+ A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0);
+ post(fiddle_version);
+}
+
+void fiddle_setup(void)
+{
+ fiddle_tilde_setup();
+}
+#endif /* PD */
+
+#ifdef MAX26
+
+void cu_fiddle(float *in1, t_sigfiddle *x, int n)
+{
+ int count;
+ float *fp, *fp2;
+ for (count = 0, fp = x->x_inbuf + x->x_phase;
+ count < n; count++) *fp++ = *in1++;
+ if (fp == x->x_inbuf + x->x_hop)
+ {
+ sigfiddle_doit(x);
+ x->x_phase = 0;
+ if (x->x_auto) clock_delay(x->x_clock, 0L);
+ if (x->x_nprint) x->x_nprint--;
+ }
+ else x->x_phase += n;
+}
+
+void sigfiddle_put(t_sigfiddle *x, long whether)
+{
+ if (whether)
+ {
+ u_stdout(x);
+ x->x_sr = x->x_io[0]->s_sr;
+ sigfiddle_reattack(x, x->x_attacktime, x->x_attackthresh);
+ sigfiddle_vibrato(x, x->x_vibtime, x->x_vibdepth);
+ dspchain_addc(cu_fiddle, 3,
+ x->x_io[0]->s_shit, x, x->x_io[0]->s_n);
+ }
+}
+
+void sigfiddle_tick(t_sigfiddle *x) /* callback function for the clock */
+{
+ int i;
+ t_pitchhist *ph;
+ outlet_float(x->x_envout, x->x_dbs[x->x_histphase]);
+ for (i = 0, ph = x->x_hist; i < x->x_npitch; i++, ph++)
+ {
+ t_atom at[2];
+ SETFLOAT(at, ph->h_pitches[x->x_histphase]);
+ SETFLOAT(at+1, ph->h_amps[x->x_histphase]);
+ outlet_list(ph->h_outlet, NIL, 2, at);
+ }
+ if (x->x_attackvalue) outlet_bang(x->x_attackout);
+ for (i = 0, ph = x->x_hist; i < x->x_npitch; i++, ph++)
+ if (ph->h_pitch) outlet_float(x->x_noteout, ph->h_pitch);
+}
+
+void sigfiddle_ff(t_sigfiddle *x) /* cleanup on free */
+{
+ if (x->x_inbuf)
+ {
+ freebytes(x->x_inbuf, sizeof(float) * x->x_hop);
+ freebytes(x->x_lastanalysis, sizeof(float) * (2*x->x_hop + 4 * FILTSIZE));
+ freebytes(x->x_spiral, sizeof(float) * 2*x->x_hop);
+ clock_free(x->x_clock);
+ u_clean(x);
+ }
+}
+
+t_externclass *sigfiddle_class;
+
+void *sigfiddle_new(long npoints, long npitch,
+ long npeakanal, long npeakout)
+{
+ t_sigfiddle *x = (t_sigfiddle *)obj_new(&sigfiddle_class, 0);
+ int i;
+
+ if (!sigfiddle_doinit(x, npoints, npitch, npeakanal, npeakout))
+ {
+ x->x_inbuf = 0; /* prevent the free routine from cleaning up */
+ obj_free(x);
+ return (0);
+ }
+ u_setup(x, IN1, OUT0);
+ x->x_envout = outlet_new(x, gensym("float"));
+ for (i = 0; i < x->x_npitch; i++)
+ x->x_hist[i].h_outlet = outlet_new(x, gensym("list"));
+ x->x_attackout = outlet_new(x, gensym("bang"));
+ x->x_noteout = outlet_new(x, gensym("float"));
+ x->x_clock = clock_new(x, sigfiddle_tick);
+ return (x);
+}
+
+void fiddle_setup()
+{
+ c_extern(&sigfiddle_class, sigfiddle_new, sigfiddle_ff,
+ gensym("fiddle"), sizeof(t_sigfiddle), 0, A_DEFLONG, A_DEFLONG,
+ A_DEFLONG, A_DEFLONG, 0);
+ c_addmess(sigfiddle_put, gensym("put"), A_CANT, 0);
+ c_addmess(sigfiddle_debug, gensym("debug"), 0);
+ c_addmess(sigfiddle_amprange, gensym("amp-range"), A_FLOAT, A_FLOAT, 0);
+ c_addmess(sigfiddle_reattack, gensym("reattack"), A_FLOAT, A_FLOAT, 0);
+ c_addmess(sigfiddle_vibrato, gensym("vibrato"), A_LONG, A_FLOAT, 0);
+ c_addmess(sigfiddle_npartial, gensym("npartial"), A_FLOAT, 0);
+ c_addmess(sigfiddle_print, gensym("print"), 0);
+ u_inletmethod(0); /* one signal input */
+#ifdef MAX
+ post(fiddle_version);
+#endif
+}
+
+#endif /* MAX26 */
+
+/************* Beginning of MSP Code ******************************/
+
+#ifdef MSP
+
+static t_int *fiddle_perform(t_int *w)
+{
+ t_float *in = (t_float *)(w[1]);
+ t_sigfiddle *x = (t_sigfiddle *)(w[2]);
+ int n = (int)(w[3]);
+ int count,inc = x->x_downsample;
+ float *fp;
+
+ if (x->x_obj.z_disabled)
+ goto skip;
+ for (count = 0, fp = x->x_inbuf + x->x_phase; count < n; count+=inc) {
+ *fp++ = *in;
+ in += inc;
+ }
+ if (fp == x->x_inbuf + x->x_hop)
+ {
+ sigfiddle_doit(x);
+ x->x_phase = 0;
+ if (x->x_auto) clock_delay(x->x_clock, 0L);
+ if (x->x_nprint) x->x_nprint--;
+ }
+ else x->x_phase += n;
+skip:
+ return (w+4);
+}
+
+void sigfiddle_dsp(t_sigfiddle *x, t_signal **sp)
+{
+ if (sp[0]->s_n > x->x_hop) {
+ x->x_downsample = sp[0]->s_n / x->x_hop;
+ post("* warning: fiddle~: will downsample input by
+%ld",x->x_downsample);
+ x->x_sr = sp[0]->s_sr / x->x_downsample;
+ } else {
+ x->x_downsample = 1;
+ x->x_sr = sp[0]->s_sr;
+ }
+ sigfiddle_reattack(x, x->x_attacktime, x->x_attackthresh);
+ sigfiddle_vibrato(x, x->x_vibtime, x->x_vibdepth);
+ dsp_add(fiddle_perform, 3, sp[0]->s_vec, x, sp[0]->s_n);
+}
+
+void sigfiddle_tick(t_sigfiddle *x) /* callback function for the clock
+MSP*/
+{
+ int i;
+ t_pitchhist *ph;
+ if (x->x_npeakout)
+ {
+ int npeakout = x->x_npeakout;
+ t_peakout *po;
+ for (i = 0, po = x->x_peakbuf; i < npeakout; i++, po++)
+ {
+ t_atom at[3];
+ SETINT(at, i+1);
+ SETFLOAT(at+1, po->po_freq);
+ SETFLOAT(at+2, po->po_amp);
+ outlet_list(x->x_peakout, 0, 3, at);
+ }
+ }
+ outlet_float(x->x_envout, x->x_dbs[x->x_histphase]);
+ for (i = 0, ph = x->x_hist; i < x->x_npitch; i++, ph++)
+ {
+ t_atom at[2];
+ SETFLOAT(at, ph->h_pitches[x->x_histphase]);
+ SETFLOAT(at+1, ph->h_amps[x->x_histphase]);
+ outlet_list(ph->h_outlet, 0, 2, at);
+ }
+ if (x->x_attackvalue) outlet_bang(x->x_attackout);
+ for (i = 0, ph = x->x_hist; i < x->x_npitch; i++, ph++)
+ if (ph->h_pitch) outlet_float(x->x_noteout, ph->h_pitch);
+}
+
+void sigfiddle_bang(t_sigfiddle *x) // MSP
+{
+ int i;
+ t_pitchhist *ph;
+ if (x->x_npeakout)
+ {
+ int npeakout = x->x_npeakout;
+ t_peakout *po;
+ for (i = 0, po = x->x_peakbuf; i < npeakout; i++, po++)
+ {
+ t_atom at[3];
+ SETLONG(at, i+1);
+ SETFLOAT(at+1, po->po_freq);
+ SETFLOAT(at+2, po->po_amp);
+ outlet_list(x->x_peakout, 0, 3, at);
+ }
+ }
+ outlet_float(x->x_envout, x->x_dbs[x->x_histphase]);
+ for (i = 0, ph = x->x_hist; i < x->x_npitch; i++, ph++)
+ {
+ t_atom at[2];
+ SETFLOAT(at, ph->h_pitches[x->x_histphase]);
+ SETFLOAT(at+1, ph->h_amps[x->x_histphase]);
+ outlet_list(ph->h_outlet, 0, 2, at);
+ }
+ if (x->x_attackvalue) outlet_bang(x->x_attackout);
+ for (i = 0, ph = x->x_hist; i < x->x_npitch; i++, ph++)
+ if (ph->h_pitch) outlet_float(x->x_noteout, ph->h_pitch);
+}
+
+
+void sigfiddle_ff(t_sigfiddle *x) /* cleanup on free MSP */
+{
+
+ if (x->x_inbuf)
+ {
+ t_freebytes(x->x_inbuf, sizeof(float) * x->x_hop);
+ t_freebytes(x->x_lastanalysis, sizeof(float) * (2*x->x_hop + 4 *
+FILTSIZE));
+ t_freebytes(x->x_spiral, sizeof(float) * 2*x->x_hop);
+ t_freebytes(x->x_peakbuf, sizeof(*x->x_peakbuf) * x->x_npeakout);
+ //clock_free(x->x_clock);
+ }
+ dsp_free((t_pxobject *)x); // Free the object
+}
+
+void *sigfiddle_class;
+
+void *sigfiddle_new(long npoints, long npitch, // MSP
+ long npeakanal, long npeakout)
+{
+ t_sigfiddle *x = (t_sigfiddle *)newobject(sigfiddle_class);
+ int i;
+
+ if (!sigfiddle_doinit(x, npoints, npitch, npeakanal, npeakout))
+ // MSP
+ {
+ x->x_inbuf = 0; /* prevent the free routine from cleaning up */
+ return (0);
+ }
+ // post("npeak %d, npitch %d", npeakout, npitch);
+ // set up the inlets and outlets.
+ dsp_setup((t_pxobject *)x,1); // 1 input
+
+ x->x_clock = clock_new(x, (method)sigfiddle_tick);
+ if (x->x_npeakout)
+ x->x_peakout = listout((t_object *)x); // listout?
+ else x->x_peakout = 0;
+ x->x_envout = floatout((t_object *)x);
+ for (i = 0; i < x->x_npitch; i++)
+ x->x_hist[i].h_outlet = listout((t_object *)x);
+ x->x_attackout = bangout((t_object *)x);
+ x->x_noteout = floatout((t_object *)x);
+ return (x);
+
+
+}
+
+void main() // this can be called fiddle_setup if that name is the "Main"
+in PPC Linker prefs
+{
+ setup(&sigfiddle_class, sigfiddle_new, (method)sigfiddle_ff,
+ (short)sizeof(t_sigfiddle), 0L, A_DEFLONG, A_DEFLONG,
+A_DEFLONG, A_DEFLONG, 0);
+ addmess((method)sigfiddle_dsp, "dsp",
+ A_CANT, 0);
+ addmess((method)sigfiddle_debug, "debug", 0);
+ addmess((method)sigfiddle_amprange, "amp-range", A_FLOAT, A_FLOAT, 0);
+ addmess((method)sigfiddle_reattack, "reattack", A_FLOAT, A_FLOAT, 0);
+ addmess((method)sigfiddle_vibrato, "vibrato", A_FLOAT,
+A_FLOAT, 0);
+ addmess((method)sigfiddle_npartial, "npartial", A_FLOAT, 0);
+ addmess((method)sigfiddle_auto, "auto",
+ A_FLOAT, 0);
+ addmess((method)sigfiddle_print, "print", 0);
+ addmess((method)sigfiddle_assist, "assist",
+ A_CANT, 0);
+ addbang((method)sigfiddle_bang);
+ dsp_initclass();
+ rescopy('STR#',3748);
+ post(fiddle_version);
+}
+
+void sigfiddle_assist(t_sigfiddle *x, void *b, long m, long a, char *s)
+{
+ assist_string(3748,m,a,1,2,s);
+}
+
+void msp_fft(float *buf, long np, long inv)
+{
+ float *src,*real,*rp,*imag,*ip;
+ long i;
+
+ // because this fft algorithm uses separate real and imaginary
+ // buffers
+ // we must split the real and imaginary parts into two buffers,
+ // then do the opposite on output
+ // a more ambitious person would either do an in-place conversion
+ // or rewrite the fft algorithm
+
+ real = rp = msp_ffttemp;
+ imag = ip = real + MAXPOINTS;
+ src = buf;
+ for (i = 0; i < np; i++) {
+ *rp++ = *src++;
+ *ip++ = *src++;
+ }
+ if (inv)
+ ifft(np,real,imag);
+ else
+ fft(np,real,imag);
+ rp = real;
+ ip = imag;
+ src = buf;
+ for (i = 0; i < np; i++) {
+ *src++ = *rp++;
+ *src++ = *ip++;
+ }
+}
+
+#endif /* MSP */
diff --git a/pd/extra/fiddle~/makefile b/pd/extra/fiddle~/makefile
new file mode 100644
index 00000000..a23303d3
--- /dev/null
+++ b/pd/extra/fiddle~/makefile
@@ -0,0 +1,97 @@
+NAME=fiddle~
+CSYM=fiddle_tilde
+
+current: pd_linux
+
+# ----------------------- NT -----------------------
+
+pd_nt: $(NAME).dll
+
+.SUFFIXES: .dll
+
+PDNTCFLAGS = /W3 /WX /DNT /DPD /nologo
+VC="C:\Program Files\Microsoft Visual Studio\Vc98"
+
+PDNTINCLUDE = /I. /I\tcl\include /I\ftp\pd\src /I$(VC)\include
+
+PDNTLDIR = $(VC)\lib
+PDNTLIB = $(PDNTLDIR)\libc.lib \
+ $(PDNTLDIR)\oldnames.lib \
+ $(PDNTLDIR)\kernel32.lib \
+ \ftp\pd\bin\pd.lib
+
+.c.dll:
+ cl $(PDNTCFLAGS) $(PDNTINCLUDE) /c $*.c
+ link /dll /export:$(CSYM)_setup $*.obj $(PDNTLIB)
+
+# ----------------------- IRIX 5.x -----------------------
+
+pd_irix5: $(NAME).pd_irix5
+
+.SUFFIXES: .pd_irix5
+
+SGICFLAGS5 = -o32 -DPD -DUNIX -DIRIX -O2
+
+SGIINCLUDE = -I../../src
+
+.c.pd_irix5:
+ cc $(SGICFLAGS5) $(SGIINCLUDE) -o $*.o -c $*.c
+ ld -elf -shared -rdata_shared -o $*.pd_irix5 $*.o
+ rm -f $*.o ../$*.pd_linux
+ ln -s $*.pd_linux ..
+
+# ----------------------- IRIX 6.x -----------------------
+
+pd_irix6: $(NAME).pd_irix6
+
+.SUFFIXES: .pd_irix6
+
+SGICFLAGS6 = -n32 -DPD -DUNIX -DIRIX -DN32 -woff 1080,1064,1185 \
+ -OPT:roundoff=3 -OPT:IEEE_arithmetic=3 -OPT:cray_ivdep=true \
+ -Ofast=ip32
+
+.c.pd_irix6:
+ cc $(SGICFLAGS6) $(SGIINCLUDE) -o $*.o -c $*.c
+ ld -n32 -IPA -shared -rdata_shared -o $*.pd_irix6 $*.o
+ rm $*.o
+
+# ----------------------- LINUX i386 -----------------------
+
+pd_linux: $(NAME).pd_linux
+
+.SUFFIXES: .pd_linux
+
+LINUXCFLAGS = -fPIC -DPD -O2 -funroll-loops -fomit-frame-pointer \
+ -Wall -W -Wshadow -Wstrict-prototypes -Werror \
+ -Wno-unused -Wno-parentheses -Wno-switch
+
+LINUXINCLUDE = -I../../src
+
+LSTRIP = strip --strip-unneeded -R .note -R .comment
+
+.c.pd_linux:
+ cc $(LINUXCFLAGS) $(LINUXINCLUDE) -o $*.o -c $*.c
+ cc -Wl,-export_dynamic --shared -o $*.pd_linux $*.o -lm
+ $(LSTRIP) $*.pd_linux
+ rm -f $*.o ../$*.pd_linux
+ ln -s $*/$*.pd_linux ..
+
+# ----------------------- Mac OSX -----------------------
+
+pd_darwin: $(NAME).pd_darwin
+
+.SUFFIXES: .pd_darwin
+
+DARWINCFLAGS = -DPD -O2 -Wall -W -Wshadow -Wstrict-prototypes \
+ -Wno-unused -Wno-parentheses -Wno-switch
+
+.c.pd_darwin:
+ cc $(DARWINCFLAGS) $(LINUXINCLUDE) -o $*.o -c $*.c
+ cc -bundle -undefined suppress -flat_namespace -o $*.pd_darwin $*.o
+ rm -f $*.o ../$*.pd_darwin
+ ln -s $*/$*.pd_darwin ..
+
+# ----------------------------------------------------------
+
+clean:
+ rm -f *.o *.pd_* so_locations
diff --git a/pd/extra/loop~/loop~.c b/pd/extra/loop~/loop~.c
new file mode 100644
index 00000000..85588ba8
--- /dev/null
+++ b/pd/extra/loop~/loop~.c
@@ -0,0 +1,164 @@
+/* loop~ -- loop generator for sampling */
+
+/* Copyright 1997-1999 Miller Puckette.
+Permission is granted to use this software for any purpose provided you
+keep this copyright notice intact.
+
+THE AUTHOR AND HIS EMPLOYERS MAKE NO WARRANTY, EXPRESS OR IMPLIED,
+IN CONNECTION WITH THIS SOFTWARE.
+
+This file is downloadable from http://www.crca.ucsd.edu/~msp .
+
+*/
+
+#ifdef PD
+#include "m_pd.h"
+#endif
+
+typedef struct _loopctl
+{
+ double l_phase;
+ float l_invwindow;
+ float l_window;
+ int l_resync;
+} t_loopctl;
+
+static void loopctl_run(t_loopctl *x, float *transposein,
+ float *windowin, float *rawout, float *windowout, int n)
+{
+ float window, invwindow;
+ double phase = x->l_phase;
+ if (x->l_resync)
+ {
+ window = *windowin;
+ if (window < 0)
+ {
+ if (window > -1)
+ window = -1;
+ invwindow = -1/window;
+ }
+ else
+ {
+ if (window < 1)
+ window = 1;
+ invwindow = 1/window;
+ }
+ x->l_resync = 0;
+ }
+ else
+ {
+ window = x->l_window;
+ phase = x->l_phase;
+ invwindow = x->l_invwindow;
+ }
+ while (n--)
+ {
+ double phaseinc = invwindow * *transposein++;
+ double newphase;
+ float nwind = *windowin++;
+ if (phaseinc >= 1 || phaseinc < 0)
+ phaseinc = 0;
+ newphase = phase + phaseinc;
+ if (newphase >= 1)
+ {
+ window = nwind;
+ if (window < 0)
+ {
+ if (window > -1)
+ window = -1;
+ invwindow = -1/window;
+ }
+ else
+ {
+ if (window < 1)
+ window = 1;
+ invwindow = 1/window;
+ }
+ newphase -= 1.;
+ }
+ phase = newphase;
+ *rawout++ = (float)phase;
+ *windowout++ = window;
+ }
+ x->l_invwindow = invwindow;
+ x->l_window = window;
+ x->l_phase = phase;
+}
+
+static void loopctl_init(t_loopctl *x)
+{
+ x->l_window = 1;
+ x->l_invwindow = 1;
+ x->l_phase = 0;
+}
+
+static void loopctl_set(t_loopctl *x, float val)
+{
+ if (val < 0 || val > 1)
+ val = 0;
+ x->l_phase = val;
+ x->l_resync = 1;
+}
+
+#ifdef PD
+
+typedef struct _loop
+{
+ t_object x_obj;
+ t_float x_f;
+ t_loopctl x_loopctl;
+} t_loop;
+
+static t_class *loop_class;
+
+static void *loop_new(void)
+{
+ t_loop *x = (t_loop *)pd_new(loop_class);
+ loopctl_init(&x->x_loopctl);
+ inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_signal, &s_signal);
+ outlet_new(&x->x_obj, gensym("signal"));
+ outlet_new(&x->x_obj, gensym("signal"));
+ return (x);
+}
+
+static t_int *loop_perform(t_int *w)
+{
+ t_loopctl *ctl = (t_loopctl *)(w[1]);
+ t_float *in1 = (t_float *)(w[2]);
+ t_float *in2 = (t_float *)(w[3]);
+ t_float *out1 = (t_float *)(w[4]);
+ t_float *out2 = (t_float *)(w[5]);
+ int n = (int)(w[6]);
+ loopctl_run(ctl, in1, in2, out1, out2, n);
+ return (w+7);
+}
+
+static void loop_dsp(t_loop *x, t_signal **sp)
+{
+ dsp_add(loop_perform, 6,
+ &x->x_loopctl, sp[0]->s_vec, sp[1]->s_vec, sp[2]->s_vec, sp[3]->s_vec,
+ sp[0]->s_n);
+}
+
+static void loop_set(t_loop *x, t_floatarg val)
+{
+ loopctl_set(&x->x_loopctl, val);
+}
+
+static void loop_bang(t_loop *x)
+{
+ loopctl_set(&x->x_loopctl, 0);
+}
+
+void loop_tilde_setup(void)
+{
+ loop_class = class_new(gensym("loop~"), (t_newmethod)loop_new, 0,
+ sizeof(t_loop), 0, 0);
+ class_addmethod(loop_class, (t_method)loop_dsp, gensym("dsp"), A_CANT, 0);
+ CLASS_MAINSIGNALIN(loop_class, t_loop, x_f);
+ class_addmethod(loop_class, (t_method)loop_set, gensym("set"),
+ A_DEFFLOAT, 0);
+ class_addbang(loop_class, loop_bang);
+}
+
+#endif /* PD */
diff --git a/pd/extra/loop~/makefile b/pd/extra/loop~/makefile
new file mode 100644
index 00000000..7adffbd6
--- /dev/null
+++ b/pd/extra/loop~/makefile
@@ -0,0 +1,97 @@
+NAME=loop~
+CSYM=loop_tilde
+
+current: pd_linux
+
+# ----------------------- NT -----------------------
+
+pd_nt: $(NAME).dll
+
+.SUFFIXES: .dll
+
+PDNTCFLAGS = /W3 /WX /DNT /DPD /nologo
+VC="C:\Program Files\Microsoft Visual Studio\Vc98"
+
+PDNTINCLUDE = /I. /I\tcl\include /I\ftp\pd\src /I$(VC)\include
+
+PDNTLDIR = $(VC)\lib
+PDNTLIB = $(PDNTLDIR)\libc.lib \
+ $(PDNTLDIR)\oldnames.lib \
+ $(PDNTLDIR)\kernel32.lib \
+ \ftp\pd\bin\pd.lib
+
+.c.dll:
+ cl $(PDNTCFLAGS) $(PDNTINCLUDE) /c $*.c
+ link /dll /export:$(CSYM)_setup $*.obj $(PDNTLIB)
+
+# ----------------------- IRIX 5.x -----------------------
+
+pd_irix5: $(NAME).pd_irix5
+
+.SUFFIXES: .pd_irix5
+
+SGICFLAGS5 = -o32 -DPD -DUNIX -DIRIX -O2
+
+SGIINCLUDE = -I../../src
+
+.c.pd_irix5:
+ cc $(SGICFLAGS5) $(SGIINCLUDE) -o $*.o -c $*.c
+ ld -elf -shared -rdata_shared -o $*.pd_irix5 $*.o
+ rm -f $*.o ../$*.pd_linux
+ ln -s $*.pd_linux ..
+
+# ----------------------- IRIX 6.x -----------------------
+
+pd_irix6: $(NAME).pd_irix6
+
+.SUFFIXES: .pd_irix6
+
+SGICFLAGS6 = -n32 -DPD -DUNIX -DIRIX -DN32 -woff 1080,1064,1185 \
+ -OPT:roundoff=3 -OPT:IEEE_arithmetic=3 -OPT:cray_ivdep=true \
+ -Ofast=ip32
+
+.c.pd_irix6:
+ cc $(SGICFLAGS6) $(SGIINCLUDE) -o $*.o -c $*.c
+ ld -n32 -IPA -shared -rdata_shared -o $*.pd_irix6 $*.o
+ rm $*.o
+
+# ----------------------- LINUX i386 -----------------------
+
+pd_linux: $(NAME).pd_linux
+
+.SUFFIXES: .pd_linux
+
+LINUXCFLAGS = -fPIC -DPD -O2 -funroll-loops -fomit-frame-pointer \
+ -Wall -W -Wshadow -Wstrict-prototypes -Werror \
+ -Wno-unused -Wno-parentheses -Wno-switch
+
+LINUXINCLUDE = -I../../src
+
+LSTRIP = strip --strip-unneeded -R .note -R .comment
+
+.c.pd_linux:
+ cc $(LINUXCFLAGS) $(LINUXINCLUDE) -o $*.o -c $*.c
+ cc -Wl,-export_dynamic --shared -o $*.pd_linux $*.o -lm
+ $(LSTRIP) $*.pd_linux
+ rm -f $*.o ../$*.pd_linux
+ ln -s $*/$*.pd_linux ..
+
+# ----------------------- Mac OSX -----------------------
+
+pd_darwin: $(NAME).pd_darwin
+
+.SUFFIXES: .pd_darwin
+
+DARWINCFLAGS = -DPD -O2 -Wall -W -Wshadow -Wstrict-prototypes \
+ -Wno-unused -Wno-parentheses -Wno-switch
+
+.c.pd_darwin:
+ cc $(DARWINCFLAGS) $(LINUXINCLUDE) -o $*.o -c $*.c
+ cc -bundle -undefined suppress -flat_namespace -o $*.pd_darwin $*.o
+ rm -f $*.o ../$*.pd_darwin
+ ln -s $*/$*.pd_darwin ..
+
+# ----------------------------------------------------------
+
+clean:
+ rm -f *.o *.pd_* so_locations
diff --git a/pd/extra/loop~/test-loop~.pd b/pd/extra/loop~/test-loop~.pd
new file mode 100644
index 00000000..9f454109
--- /dev/null
+++ b/pd/extra/loop~/test-loop~.pd
@@ -0,0 +1,56 @@
+#N canvas 33 0 498 586 12;
+#X floatatom 52 262;
+#X obj 261 346 print~;
+#X msg 57 370 bang;
+#X msg 274 313 bang;
+#X obj 52 306 loop~;
+#X floatatom 102 245;
+#X graph graph1 0 0 44100 10 120 186 320 36;
+#X array array1 44100 float;
+#X pop;
+#X msg 43 204 \; array1 resize 44100;
+#X obj 25 401 tabwrite~ array1;
+#X msg 180 376 bang;
+#X obj 148 407 tabwrite~ array1;
+#X msg 194 261 bang;
+#X obj 204 347 print~;
+#X msg 217 314 bang;
+#X graph graph1 0 -1 150000 1 273 543 473 393;
+#X array array2 150000 float;
+#X pop;
+#X msg 326 274 \; array2 resize 150000;
+#X obj 235 234 soundfiler;
+#X msg 215 199 read ../../../ham/Hamburger.wav array2;
+#X obj 103 529 tabread4~ array2;
+#X obj 64 496 *~;
+#X obj 107 581 dac~;
+#X obj 105 552 hip~ 5;
+#X obj 123 482 samphold~;
+#X obj 102 506 +~;
+#X floatatom 106 430;
+#X obj 108 453 *~ 1000;
+#X msg 222 169 read ../../../ham/Wrong.wav array2;
+#X connect 0 0 4 0;
+#X connect 2 0 8 0;
+#X connect 3 0 1 0;
+#X connect 4 0 12 0;
+#X connect 4 0 19 0;
+#X connect 4 0 8 0;
+#X connect 4 0 22 1;
+#X connect 4 1 10 0;
+#X connect 4 1 1 0;
+#X connect 4 1 19 1;
+#X connect 5 0 4 1;
+#X connect 9 0 10 0;
+#X connect 11 0 4 0;
+#X connect 13 0 12 0;
+#X connect 17 0 16 0;
+#X connect 18 0 21 0;
+#X connect 19 0 23 0;
+#X connect 21 0 20 0;
+#X connect 21 0 20 1;
+#X connect 22 0 23 1;
+#X connect 23 0 18 0;
+#X connect 24 0 25 0;
+#X connect 25 0 22 0;
+#X connect 26 0 16 0;
diff --git a/pd/extra/lrshift~/lrshift~.c b/pd/extra/lrshift~/lrshift~.c
new file mode 100644
index 00000000..285696e2
--- /dev/null
+++ b/pd/extra/lrshift~/lrshift~.c
@@ -0,0 +1,74 @@
+#include "m_pd.h"
+
+/* ------------------------ lrshift~ ----------------------------- */
+
+static t_class *lrshift_tilde_class;
+
+typedef struct _lrshift_tilde
+{
+ t_object x_obj;
+ int x_n;
+} t_lrshift_tilde;
+
+static t_int *leftshift_perform(t_int *w)
+{
+ t_float *in = (t_float *)(w[1]);
+ t_float *out= (t_float *)(w[2]);
+ int n = (int)(w[3]);
+ int shift = (int)(w[4]);
+ in += shift;
+ n -= shift;
+ while (n--)
+ *out++ = *in++;
+ while (shift--)
+ *out++ = 0;
+ return (w+5);
+}
+
+static t_int *rightshift_perform(t_int *w)
+{
+ t_float *in = (t_float *)(w[1]);
+ t_float *out= (t_float *)(w[2]);
+ int n = (int)(w[3]);
+ int shift = (int)(w[4]);
+ n -= shift;
+ in -= shift;
+ while (n--)
+ *--out = *--in;
+ while (shift--)
+ *--out = 0;
+ return (w+5);
+}
+
+static void lrshift_tilde_dsp(t_lrshift_tilde *x, t_signal **sp)
+{
+ int n = sp[0]->s_n;
+ int shift = x->x_n;
+ if (shift > n)
+ shift = n;
+ if (shift < -n)
+ shift = -n;
+ if (shift < 0)
+ dsp_add(rightshift_perform, 4,
+ sp[0]->s_vec + n, sp[1]->s_vec + n, n, -shift);
+ else dsp_add(leftshift_perform, 4,
+ sp[0]->s_vec, sp[1]->s_vec, n, shift);
+}
+
+static void *lrshift_tilde_new(t_floatarg f)
+{
+ t_lrshift_tilde *x = (t_lrshift_tilde *)pd_new(lrshift_tilde_class);
+ x->x_n = f;
+ outlet_new(&x->x_obj, gensym("signal"));
+ return (x);
+}
+
+void lrshift_tilde_setup(void)
+{
+ lrshift_tilde_class = class_new(gensym("lrshift~"),
+ (t_newmethod)lrshift_tilde_new, 0, sizeof(t_lrshift_tilde), 0,
+ A_DEFFLOAT, 0);
+ class_addmethod(lrshift_tilde_class, nullfn, gensym("signal"), 0);
+ class_addmethod(lrshift_tilde_class, (t_method)lrshift_tilde_dsp,
+ gensym("dsp"), 0);
+}
diff --git a/pd/extra/lrshift~/makefile b/pd/extra/lrshift~/makefile
new file mode 100644
index 00000000..99c1f83c
--- /dev/null
+++ b/pd/extra/lrshift~/makefile
@@ -0,0 +1,97 @@
+NAME=lrshift~
+CSYM=lrshift_tilde
+
+current: pd_linux
+
+# ----------------------- NT -----------------------
+
+pd_nt: $(NAME).dll
+
+.SUFFIXES: .dll
+
+PDNTCFLAGS = /W3 /WX /DNT /DPD /nologo
+VC="C:\Program Files\Microsoft Visual Studio\Vc98"
+
+PDNTINCLUDE = /I. /I\tcl\include /I\ftp\pd\src /I$(VC)\include
+
+PDNTLDIR = $(VC)\lib
+PDNTLIB = $(PDNTLDIR)\libc.lib \
+ $(PDNTLDIR)\oldnames.lib \
+ $(PDNTLDIR)\kernel32.lib \
+ \ftp\pd\bin\pd.lib
+
+.c.dll:
+ cl $(PDNTCFLAGS) $(PDNTINCLUDE) /c $*.c
+ link /dll /export:$(CSYM)_setup $*.obj $(PDNTLIB)
+
+# ----------------------- IRIX 5.x -----------------------
+
+pd_irix5: $(NAME).pd_irix5
+
+.SUFFIXES: .pd_irix5
+
+SGICFLAGS5 = -o32 -DPD -DUNIX -DIRIX -O2
+
+SGIINCLUDE = -I../../src
+
+.c.pd_irix5:
+ cc $(SGICFLAGS5) $(SGIINCLUDE) -o $*.o -c $*.c
+ ld -elf -shared -rdata_shared -o $*.pd_irix5 $*.o
+ rm -f $*.o ../$*.pd_linux
+ ln -s $*.pd_linux ..
+
+# ----------------------- IRIX 6.x -----------------------
+
+pd_irix6: $(NAME).pd_irix6
+
+.SUFFIXES: .pd_irix6
+
+SGICFLAGS6 = -n32 -DPD -DUNIX -DIRIX -DN32 -woff 1080,1064,1185 \
+ -OPT:roundoff=3 -OPT:IEEE_arithmetic=3 -OPT:cray_ivdep=true \
+ -Ofast=ip32
+
+.c.pd_irix6:
+ cc $(SGICFLAGS6) $(SGIINCLUDE) -o $*.o -c $*.c
+ ld -n32 -IPA -shared -rdata_shared -o $*.pd_irix6 $*.o
+ rm $*.o
+
+# ----------------------- LINUX i386 -----------------------
+
+pd_linux: $(NAME).pd_linux
+
+.SUFFIXES: .pd_linux
+
+LINUXCFLAGS = -fPIC -DPD -O2 -funroll-loops -fomit-frame-pointer \
+ -Wall -W -Wshadow -Wstrict-prototypes -Werror \
+ -Wno-unused -Wno-parentheses -Wno-switch
+
+LINUXINCLUDE = -I../../src
+
+LSTRIP = strip --strip-unneeded -R .note -R .comment
+
+.c.pd_linux:
+ cc $(LINUXCFLAGS) $(LINUXINCLUDE) -o $*.o -c $*.c
+ cc -Wl,-export_dynamic --shared -o $*.pd_linux $*.o -lm
+ $(LSTRIP) $*.pd_linux
+ rm -f $*.o ../$*.pd_linux
+ ln -s $*/$*.pd_linux ..
+
+# ----------------------- Mac OSX -----------------------
+
+pd_darwin: $(NAME).pd_darwin
+
+.SUFFIXES: .pd_darwin
+
+DARWINCFLAGS = -DPD -O2 -Wall -W -Wshadow -Wstrict-prototypes \
+ -Wno-unused -Wno-parentheses -Wno-switch
+
+.c.pd_darwin:
+ cc $(DARWINCFLAGS) $(LINUXINCLUDE) -o $*.o -c $*.c
+ cc -bundle -undefined suppress -flat_namespace -o $*.pd_darwin $*.o
+ rm -f $*.o ../$*.pd_darwin
+ ln -s $*/$*.pd_darwin ..
+
+# ----------------------------------------------------------
+
+clean:
+ rm -f *.o *.pd_* so_locations
diff --git a/pd/extra/paf~/README.txt b/pd/extra/paf~/README.txt
new file mode 100644
index 00000000..9bd41879
--- /dev/null
+++ b/pd/extra/paf~/README.txt
@@ -0,0 +1,12 @@
+Paf is copyright (C) 1999 Miller Puckette.
+Permission is granted to use this software for any purpose, commercial
+or noncommercial, as long as this notice is included with all copies.
+
+NEITHER THE AUTHORS NOR THEIR EMPLOYERS MAKE ANY WARRANTY, EXPRESS OR IMPLIED,
+IN CONNECTION WITH THIS SOFTWARE!
+
+----------------------------------------------------------------------------
+
+This is the README file for the "paf" percussion detector. This software
+is available from http://www.crca.ucsd.edu/~msp as part of the "toys"
+library. - msp@ucsd.edu
diff --git a/pd/extra/paf~/makefile b/pd/extra/paf~/makefile
new file mode 100644
index 00000000..cb06b555
--- /dev/null
+++ b/pd/extra/paf~/makefile
@@ -0,0 +1,97 @@
+NAME=paf~
+CSYM=paf_tilde
+
+current: pd_linux
+
+# ----------------------- NT -----------------------
+
+pd_nt: $(NAME).dll
+
+.SUFFIXES: .dll
+
+PDNTCFLAGS = /W3 /WX /DNT /DPD /nologo
+VC="C:\Program Files\Microsoft Visual Studio\Vc98"
+
+PDNTINCLUDE = /I. /I\tcl\include /I\ftp\pd\src /I$(VC)\include
+
+PDNTLDIR = $(VC)\lib
+PDNTLIB = $(PDNTLDIR)\libc.lib \
+ $(PDNTLDIR)\oldnames.lib \
+ $(PDNTLDIR)\kernel32.lib \
+ \ftp\pd\bin\pd.lib
+
+.c.dll:
+ cl $(PDNTCFLAGS) $(PDNTINCLUDE) /c $*.c
+ link /dll /export:$(CSYM)_setup $*.obj $(PDNTLIB)
+
+# ----------------------- IRIX 5.x -----------------------
+
+pd_irix5: $(NAME).pd_irix5
+
+.SUFFIXES: .pd_irix5
+
+SGICFLAGS5 = -o32 -DPD -DUNIX -DIRIX -O2
+
+SGIINCLUDE = -I../../src
+
+.c.pd_irix5:
+ cc $(SGICFLAGS5) $(SGIINCLUDE) -o $*.o -c $*.c
+ ld -elf -shared -rdata_shared -o $*.pd_irix5 $*.o
+ rm -f $*.o ../$*.pd_linux
+ ln -s $*.pd_linux ..
+
+# ----------------------- IRIX 6.x -----------------------
+
+pd_irix6: $(NAME).pd_irix6
+
+.SUFFIXES: .pd_irix6
+
+SGICFLAGS6 = -n32 -DPD -DUNIX -DIRIX -DN32 -woff 1080,1064,1185 \
+ -OPT:roundoff=3 -OPT:IEEE_arithmetic=3 -OPT:cray_ivdep=true \
+ -Ofast=ip32
+
+.c.pd_irix6:
+ cc $(SGICFLAGS6) $(SGIINCLUDE) -o $*.o -c $*.c
+ ld -n32 -IPA -shared -rdata_shared -o $*.pd_irix6 $*.o
+ rm $*.o
+
+# ----------------------- LINUX i386 -----------------------
+
+pd_linux: $(NAME).pd_linux
+
+.SUFFIXES: .pd_linux
+
+LINUXCFLAGS = -fPIC -DPD -O2 -funroll-loops -fomit-frame-pointer \
+ -Wall -W -Wshadow -Wstrict-prototypes -Werror \
+ -Wno-unused -Wno-parentheses -Wno-switch
+
+LINUXINCLUDE = -I../../src
+
+LSTRIP = strip --strip-unneeded -R .note -R .comment
+
+.c.pd_linux:
+ cc $(LINUXCFLAGS) $(LINUXINCLUDE) -o $*.o -c $*.c
+ cc -Wl,-export_dynamic --shared -o $*.pd_linux $*.o -lm
+ $(LSTRIP) $*.pd_linux
+ rm -f $*.o ../$*.pd_linux
+ ln -s $*/$*.pd_linux ..
+
+# ----------------------- Mac OSX -----------------------
+
+pd_darwin: $(NAME).pd_darwin
+
+.SUFFIXES: .pd_darwin
+
+DARWINCFLAGS = -DPD -O2 -Wall -W -Wshadow -Wstrict-prototypes \
+ -Wno-unused -Wno-parentheses -Wno-switch
+
+.c.pd_darwin:
+ cc $(DARWINCFLAGS) $(LINUXINCLUDE) -o $*.o -c $*.c
+ cc -bundle -undefined suppress -flat_namespace -o $*.pd_darwin $*.o
+ rm -f $*.o ../$*.pd_darwin
+ ln -s $*/$*.pd_darwin ..
+
+# ----------------------------------------------------------
+
+clean:
+ rm -f *.o *.pd_* so_locations
diff --git a/pd/extra/paf~/paf~.c b/pd/extra/paf~/paf~.c
new file mode 100644
index 00000000..4a1fec07
--- /dev/null
+++ b/pd/extra/paf~/paf~.c
@@ -0,0 +1,927 @@
+/* paf -- version of the paf generator derived from "jupiterpaf", from
+Manoury's Jupiter, 1997 version. Can be compiled as a standalone test program,
+or as an object in Max 0.26, JMAX, or Pd. */
+
+/* Copyright 1997-1999 Miller Puckette.
+Permission is granted to use this software for any purpose provided you
+keep this copyright notice intact.
+
+THE AUTHOR AND HIS EMPLOYERS MAKE NO WARRANTY, EXPRESS OR IMPLIED,
+IN CONNECTION WITH THIS SOFTWARE.
+
+This file is downloadable from http://www.crca.ucsd.edu/~msp .
+
+Warning: the algorithms implemented here are covered by patents held by
+IRCAM. While this probably does not restrict anyone from distributing
+software implementing the paf, any hardware implementor should obtain a
+license from IRCAM.
+*/
+
+static char *paf_version = "paf version 0.06";
+
+#ifdef NT
+#pragma warning (disable: 4305 4244)
+#endif
+
+#ifdef TESTME
+#include <stdio.h>
+#endif
+#ifdef FTS15
+#include "mess.h"
+#include "dsp.h"
+#endif
+#ifdef V26SGI
+#include "m_extern.h"
+#include "d_graph.h"
+#include "d_ugen.h"
+#endif
+#ifdef PD
+#include "m_pd.h"
+#endif
+#include <math.h>
+
+#define LOGTABSIZE 9
+#define TABSIZE (1 << LOGTABSIZE)
+#define TABRANGE 3
+
+typedef struct _tabpoint
+{
+ float p_y;
+ float p_diff;
+} t_tabpoint;
+
+static t_tabpoint paf_gauss[TABSIZE];
+static t_tabpoint paf_cauchy[TABSIZE];
+
+typedef struct _linenv
+{
+ double l_current;
+ double l_biginc;
+ float l_1overn;
+ float l_target;
+ float l_msectodsptick;
+ int l_ticks;
+} t_linenv;
+
+typedef struct _pafctl
+{
+ t_linenv x_freqenv;
+ t_linenv x_cfenv;
+ t_linenv x_bwenv;
+ t_linenv x_ampenv;
+ t_linenv x_vibenv;
+ t_linenv x_vfrenv;
+ t_linenv x_shiftenv;
+ float x_isr;
+ float x_held_freq;
+ float x_held_intcar;
+ float x_held_fraccar;
+ float x_held_bwquotient;
+ double x_phase;
+ double x_shiftphase;
+ double x_vibphase;
+ int x_triggerme;
+ int x_cauchy;
+} t_pafctl;
+
+static void linenv_debug(t_linenv *l, char *s)
+{
+#ifdef DEBUG
+ post("%s: current %f, target %f", s, l->l_current, l->l_target);
+#endif
+}
+
+static void linenv_init(t_linenv *l)
+{
+ l->l_current = l->l_biginc = 0;
+ l->l_1overn = l->l_target = l->l_msectodsptick = 0;
+ l->l_ticks = 0;
+}
+
+static void linenv_setsr(t_linenv *l, float sr, int vecsize)
+{
+ l->l_msectodsptick = sr / (1000.f * ((float)vecsize));
+ l->l_1overn = 1.f/(float)vecsize;
+}
+
+static void linenv_set(t_linenv *l, float target, long timdel)
+{
+ if (timdel > 0)
+ {
+ l->l_ticks = ((float)timdel) * l->l_msectodsptick;
+ if (!l->l_ticks) l->l_ticks = 1;
+ l->l_target = target;
+ l->l_biginc = (l->l_target - l->l_current)/l->l_ticks;
+ }
+ else
+ {
+ l->l_ticks = 0;
+ l->l_current = l->l_target = target;
+ l->l_biginc = 0;
+ }
+}
+
+#define LINENV_RUN(linenv, current, incr) \
+ if (linenv.l_ticks > 0) \
+ { \
+ current = linenv.l_current; \
+ incr = linenv.l_biginc * linenv.l_1overn; \
+ linenv.l_ticks--; \
+ linenv.l_current += linenv.l_biginc; \
+ } \
+ else \
+ { \
+ linenv.l_current = current = linenv.l_target; \
+ incr = 0; \
+ }
+
+#define UNITBIT32 1572864. /* 3*2^19 -- bit 32 has value 1 */
+#define TABFRACSHIFT (UNITBIT32/TABSIZE)
+
+#ifdef __sgi
+ /* machine-dependent definitions: */
+#define HIOFFSET 0 /* word offset to find MSB; endianness-dependent */
+#define LOWOFFSET 0 /* word offset to find MSB; endianness-dependent */
+#define int32 unsigned long /* a data type that has 32 bits */
+#define DONE_MACHINE_TYPE
+#endif /* __sgi */
+
+#ifdef NT
+ /* little-endian; most significant byte is at highest address */
+#define HIOFFSET 1
+#define LOWOFFSET 0
+#define int32 unsigned long
+#define DONE_MACHINE_TYPE
+#endif /* NT */
+
+#ifdef MACOSX
+#define HIOFFSET 0 /* word offset to find MSB */
+#define LOWOFFSET 1 /* word offset to find LSB */
+#define int32 int /* a data type that has 32 bits */
+#define DONE_MACHINE_TYPE
+#endif /* MACOSX */
+
+#ifdef __FreeBSD__
+#include <machine/endian.h>
+#if BYTE_ORDER == LITTLE_ENDIAN
+#define HIOFFSET 1
+#define LOWOFFSET 0
+#else
+#define HIOFFSET 0 /* word offset to find MSB */
+#define LOWOFFSET 1 /* word offset to find LSB */
+#endif /* BYTE_ORDER */
+#include <sys/types.h>
+#define int32 int32_t
+#define DONE_MACHINE_TYPE
+#endif /* __FreeBSD__ */
+
+#ifdef __linux__
+
+#include <endian.h>
+
+#if !defined(__BYTE_ORDER) || !defined(__LITTLE_ENDIAN)
+#error No byte order defined
+#endif
+
+#if __BYTE_ORDER == __LITTLE_ENDIAN
+#define HIOFFSET 1
+#define LOWOFFSET 0
+#else
+#define HIOFFSET 0 /* word offset to find MSB */
+#define LOWOFFSET 1 /* word offset to find LSB */
+#endif /* __BYTE_ORDER */
+
+#include <sys/types.h>
+#define int32 u_int32_t
+
+#define DONE_MACHINE_TYPE
+#endif /* __linux__ */
+
+#ifndef DONE_MACHINE_TYPE
+#error -- no machine architecture definition?
+#endif
+
+#define A1 ((float)(4 * (3.14159265/2)))
+#define A3 ((float)(64 * (2.5 - 3.14159265)))
+#define A5 ((float)(1024 * ((3.14159265/2) - 1.5)))
+
+static void pafctl_run(t_pafctl *x, float *out1, int n)
+{
+ float freqval, freqinc;
+ float cfval, cfinc;
+ float bwval, bwinc;
+ float ampval, ampinc;
+ float vibval, vibinc;
+ float vfrval, vfrinc;
+ float shiftval, shiftinc;
+ float bwquotient, bwqincr;
+ double ub32 = UNITBIT32;
+ double phase = x->x_phase + ub32;
+ double phasehack;
+ volatile double *phasehackp = &phasehack;
+ double shiftphase = x->x_shiftphase + ub32;
+ volatile int32 *hackptr = ((int32 *)(phasehackp)) + HIOFFSET, hackval;
+ volatile int32 *lowptr = ((int32 *)(phasehackp)) + LOWOFFSET, lowbits;
+ float held_freq = x->x_held_freq;
+ float held_intcar = x->x_held_intcar;
+ float held_fraccar = x->x_held_fraccar;
+ float held_bwquotient = x->x_held_bwquotient;
+ float sinvib, vibphase;
+ t_tabpoint *paf_table = (x->x_cauchy ? paf_cauchy : paf_gauss);
+ *phasehackp = ub32;
+ hackval = *hackptr;
+
+ /* fractional part of shift phase */
+ *phasehackp = shiftphase;
+ *hackptr = hackval;
+ shiftphase = *phasehackp;
+
+ /* propagate line envelopes */
+ LINENV_RUN(x->x_freqenv, freqval, freqinc);
+ LINENV_RUN(x->x_cfenv, cfval, cfinc);
+ LINENV_RUN(x->x_bwenv, bwval, bwinc);
+ LINENV_RUN(x->x_ampenv, ampval, ampinc);
+ LINENV_RUN(x->x_vibenv, vibval, vibinc);
+ LINENV_RUN(x->x_vfrenv, vfrval, vfrinc);
+ LINENV_RUN(x->x_shiftenv, shiftval, shiftinc);
+
+ /* fake line envelope for quotient of bw and frequency */
+ bwquotient = bwval/freqval;
+ bwqincr = (((float)(x->x_bwenv.l_current))/
+ ((float)(x->x_freqenv.l_current)) - bwquotient) *
+ x->x_freqenv.l_1overn;
+
+ /* run the vibrato oscillator */
+
+ *phasehackp = ub32 + (x->x_vibphase + n * x->x_isr * vfrval);
+ *hackptr = hackval;
+ vibphase = (x->x_vibphase = *phasehackp - ub32);
+ if (vibphase > 0.5)
+ sinvib = 1.0f - 16.0f * (0.75f-vibphase) * (0.75f - vibphase);
+ else sinvib = -1.0f + 16.0f * (0.25f-vibphase) * (0.25f - vibphase);
+ freqval = freqval * (1.0f + vibval * sinvib);
+
+ shiftval *= x->x_isr;
+ shiftinc *= x->x_isr;
+
+ /* if phase or amplitude is zero, load in new params */
+ if (ampval == 0 || phase == ub32 || x->x_triggerme)
+ {
+ float cf_over_freq = cfval/freqval;
+ held_freq = freqval * x->x_isr;
+ held_intcar = (float)((int)cf_over_freq);
+ held_fraccar = cf_over_freq - held_intcar;
+ held_bwquotient = bwquotient;
+ x->x_triggerme = 0;
+ }
+ while (n--)
+ {
+ double newphase = phase + held_freq;
+ double carphase1, carphase2, fracnewphase;
+ float fphase, fcarphase1, fcarphase2, carrier;
+ float g, g2, g3, cosine1, cosine2, halfsine, mod, tabfrac;
+ t_tabpoint *p;
+ /* put new phase into 64-bit memory location. Bash upper
+ 32 bits to get fractional part (plus "ub32"). */
+
+ *phasehackp = newphase;
+ *hackptr = hackval;
+ newphase = *phasehackp;
+ fracnewphase = newphase-ub32;
+ fphase = 2.0f * ((float)(fracnewphase)) - 1.0f;
+ if (newphase < phase)
+ {
+ float cf_over_freq = cfval/freqval;
+ held_freq = freqval * x->x_isr;
+ held_intcar = (float)((int)cf_over_freq);
+ held_fraccar = cf_over_freq - held_intcar;
+ held_bwquotient = bwquotient;
+ }
+ phase = newphase;
+ *phasehackp = fracnewphase * held_intcar + shiftphase;
+ *hackptr = hackval;
+ carphase1 = *phasehackp;
+ fcarphase1 = carphase1 - ub32;
+ *phasehackp = carphase1 + fracnewphase;
+ *hackptr = hackval;
+ carphase2 = *phasehackp;
+ fcarphase2 = carphase2 - ub32;
+
+ shiftphase += shiftval;
+
+ if (fcarphase1 > 0.5f) g = fcarphase1 - 0.75f;
+ else g = 0.25f - fcarphase1;
+ g2 = g * g;
+ g3 = g * g2;
+ cosine1 = g * A1 + g3 * A3 + g2 * g3 * A5;
+
+ if (fcarphase2 > 0.5f) g = fcarphase2 - 0.75f;
+ else g = 0.25f - fcarphase2;
+ g2 = g * g;
+ g3 = g * g2;
+ cosine2 = g * A1 + g3 * A3 + g2 * g3 * A5;
+
+ carrier = cosine1 + held_fraccar * (cosine2-cosine1);
+
+ ampval += ampinc;
+ bwquotient += bwqincr;
+
+ /* printf("bwquotient %f\n", bwquotient); */
+
+ halfsine = held_bwquotient * (1.0f - fphase * fphase);
+ if (halfsine >= (float)(0.997 * TABRANGE))
+ halfsine = (float)(0.997 * TABRANGE);
+
+#if 0
+ shape = halfsine * halfsine;
+ mod = ampval * carrier *
+ (1 - bluntval * shape) / (1 + (1 - bluntval) * shape);
+#endif
+#if 0
+ shape = halfsine * halfsine;
+ mod = ampval * carrier *
+ exp(-shape);
+#endif
+ halfsine *= (float)(1./TABRANGE);
+
+ /* Get table index for "halfsine". Bash upper
+ 32 bits to get fractional part (plus "ub32"). Also grab
+ fractional part as a fixed-point number to use as table
+ address later. */
+
+ *phasehackp = halfsine + ub32;
+ lowbits = *lowptr;
+
+ /* now shift again so that the fractional table address
+ appears in the low 32 bits, bash again, and extract this as
+ a floating point number from 0 to 1. */
+ *phasehackp = halfsine + TABFRACSHIFT;
+ *hackptr = hackval;
+ tabfrac = *phasehackp - ub32;
+
+ p = paf_table + (lowbits >> (32 - LOGTABSIZE));
+ mod = ampval * carrier * (p->p_y + tabfrac * p->p_diff);
+
+ *out1++ = mod;
+ }
+ x->x_phase = phase - ub32;
+ x->x_shiftphase = shiftphase - ub32;
+ x->x_held_freq = held_freq;
+ x->x_held_intcar = held_intcar;
+ x->x_held_fraccar = held_fraccar;
+ x->x_held_bwquotient = held_bwquotient;
+}
+
+static void pafctl_init(t_pafctl *x)
+{
+ linenv_init(&x->x_freqenv);
+ linenv_init(&x->x_cfenv);
+ linenv_init(&x->x_bwenv);
+ linenv_init(&x->x_ampenv);
+ linenv_init(&x->x_vibenv);
+ linenv_init(&x->x_vfrenv);
+ linenv_init(&x->x_shiftenv);
+ x->x_freqenv.l_target = x->x_freqenv.l_current = 1.0;
+ x->x_isr = (float)(1./44100.);
+ x->x_held_freq = 1.f;
+ x->x_held_intcar = 0.f;
+ x->x_held_fraccar = 0.f;
+ x->x_held_bwquotient = 0.f;
+ x->x_phase = 0.;
+ x->x_shiftphase = 0.;
+ x->x_vibphase = 0.;
+ x->x_triggerme = 0;
+ x->x_cauchy = 0;
+}
+
+static void pafctl_setsr(t_pafctl *x, float sr, int vecsize)
+{
+ x->x_isr = 1.f/sr;
+ linenv_setsr(&x->x_freqenv, sr, vecsize);
+ linenv_setsr(&x->x_cfenv, sr, vecsize);
+ linenv_setsr(&x->x_bwenv, sr, vecsize);
+ linenv_setsr(&x->x_ampenv, sr, vecsize);
+ linenv_setsr(&x->x_vibenv, sr, vecsize);
+ linenv_setsr(&x->x_vfrenv, sr, vecsize);
+ linenv_setsr(&x->x_shiftenv, sr, vecsize);
+}
+
+static void pafctl_freq(t_pafctl *x, float val, int time)
+{
+ if (val < 1.f) val = 1.f;
+ if (val > 10000000.f) val = 1000000.f;
+ linenv_set(&x->x_freqenv, val, time);
+}
+
+static void pafctl_cf(t_pafctl *x, float val, int time)
+{
+ linenv_set(&x->x_cfenv, val, time);
+}
+
+static void pafctl_bw(t_pafctl *x, float val, int time)
+{
+ linenv_set(&x->x_bwenv, val, time);
+}
+
+static void pafctl_amp(t_pafctl *x, float val, int time)
+{
+ linenv_set(&x->x_ampenv, val, time);
+}
+
+static void pafctl_vib(t_pafctl *x, float val, int time)
+{
+ linenv_set(&x->x_vibenv, val, time);
+}
+
+static void pafctl_vfr(t_pafctl *x, float val, int time)
+{
+ linenv_set(&x->x_vfrenv, val, time);
+}
+
+static void pafctl_shift(t_pafctl *x, float val, int time)
+{
+ linenv_set(&x->x_shiftenv, val, time);
+}
+
+static void pafctl_phase(t_pafctl *x, float mainphase, float shiftphase,
+ float vibphase)
+{
+ x->x_phase = mainphase;
+ x->x_shiftphase = shiftphase;
+ x->x_vibphase = vibphase;
+ x->x_triggerme = 1;
+}
+
+ /* value of Cauchy distribution at TABRANGE */
+#define CAUCHYVAL (1./ (1. + TABRANGE * TABRANGE))
+ /* first derivative of Cauchy distribution at TABRANGE */
+#define CAUCHYSLOPE ((-2. * TABRANGE) * CAUCHYVAL * CAUCHYVAL)
+#define ADDSQ (- CAUCHYSLOPE / (2 * TABRANGE))
+
+static void paf_dosetup(void)
+{
+ int i;
+ float CAUCHYFAKEAT3 =
+ (CAUCHYVAL + ADDSQ * TABRANGE * TABRANGE);
+ float CAUCHYRESIZE = (1./ (1. - CAUCHYFAKEAT3));
+ for (i = 0; i <= TABSIZE; i++)
+ {
+ float f = i * ((float)TABRANGE/(float)TABSIZE);
+ float gauss = exp(-f * f);
+ float cauchygenuine = 1. / (1. + f * f);
+ float cauchyfake = cauchygenuine + ADDSQ * f * f;
+ float cauchyrenorm = (cauchyfake - 1.) * CAUCHYRESIZE + 1.;
+ if (i != TABSIZE)
+ {
+ paf_gauss[i].p_y = gauss;
+ paf_cauchy[i].p_y = cauchyrenorm;
+ /* post("%f", cauchyrenorm); */
+ }
+ if (i != 0)
+ {
+ paf_gauss[i-1].p_diff = gauss - paf_gauss[i-1].p_y;
+ paf_cauchy[i-1].p_diff = cauchyrenorm - paf_cauchy[i-1].p_y;
+ }
+ }
+}
+
+#ifdef TESTME
+
+#define BS 64
+main()
+{
+ t_pafctl x;
+ float x1[BS];
+ int i;
+ paf_dosetup();
+ pafctl_init(&x);
+ pafctl_setsr(&x, 16000., BS);
+ pafctl_freq(&x, 1000, 0);
+ pafctl_bw(&x, 2000, 0);
+ pafctl_amp(&x, 1000, 0);
+ pafctl_run(&x, x1, BS);
+ for (i = 0; i < BS/4; i++)
+ {
+ printf("%15.5f %15.5f %15.5f %15.5f\n",
+ x1[4*i], x1[4*i+1], x1[4*i+2], x1[4*i+3]);
+ }
+#if 0
+ printf("\n");
+ pafctl_bw(&x, 2000, 0);
+ pafctl_run(&x, x1, BS);
+ for (i = 0; i < BS/4; i++)
+ {
+ printf("%15.5f %15.5f %15.5f %15.5f\n",
+ x1[4*i], x1[4*i+1], x1[4*i+2], x1[4*i+3]);
+ }
+#endif
+}
+
+#endif
+#ifdef FTS1X
+
+static fts_symbol_t *paf_dspname;
+
+typedef struct _paf
+{
+ fts_object_t ob; /* object header */
+ t_pafctl pafctl;
+} paf_t;
+
+/* ---------------------------------------- */
+/* Methods */
+/* ---------------------------------------- */
+
+ /* formalities... */
+
+static void paf_dspfun(fts_word_t *a)
+{
+ paf_t *x = (paf_t *)fts_word_get_obj(a);
+ float *out1 = (float *)fts_word_get_obj(a + 1);
+ long n = fts_word_get_long(a + 3);
+
+ pafctl_run(&x->pafctl, out1, n);
+}
+
+void paf_put(fts_object_t *o, int winlet, fts_symbol_t *s,
+ int ac, const fts_atom_t *at)
+{
+ paf_t *x = (paf_t *)o;
+ fts_dsp_descr_t *dsp = (fts_dsp_descr_t *)fts_get_obj_arg(at, ac, 0, 0);
+ fts_atom_t a[4];
+ float sr = fts_dsp_get_output_srate(dsp, 0);
+ int vecsize = fts_dsp_get_output_size(dsp, 0);
+
+ pafctl_setsr(&x->pafctl, sr, vecsize);
+ fts_set_obj(a, x);
+ fts_set_symbol(a+1, fts_dsp_get_output_name(dsp, 0));
+ fts_set_long(a+2, fts_dsp_get_output_size(dsp, 0));
+ dsp_add_funcall(paf_dspname, 3, a);
+}
+
+static void paf_freq(fts_object_t *o, int winlet, fts_symbol_t *s,
+ int ac, const fts_atom_t *at)
+{
+ paf_t *this = (paf_t *)o;
+ float val = fts_get_float_long_arg( at, ac, 0, 0.0f);
+ int time = fts_get_long_arg(at, ac, 1, 0);
+ pafctl_freq(&this->pafctl, val, time);
+}
+
+static void paf_cf(fts_object_t *o, int winlet, fts_symbol_t *s,
+ int ac, const fts_atom_t *at)
+{
+ paf_t *this = (paf_t *)o;
+ float val = fts_get_float_long_arg( at, ac, 0, 0.0f);
+ int time = fts_get_long_arg(at, ac, 1, 0);
+ pafctl_cf(&this->pafctl, val, time);
+}
+
+static void paf_bw(fts_object_t *o, int winlet, fts_symbol_t *s,
+ int ac, const fts_atom_t *at)
+{
+ paf_t *this = (paf_t *)o;
+ float val = fts_get_float_long_arg( at, ac, 0, 0.0f);
+ int time = fts_get_long_arg(at, ac, 1, 0);
+ pafctl_bw(&this->pafctl, val, time);
+}
+
+static void paf_amp(fts_object_t *o, int winlet, fts_symbol_t *s,
+ int ac, const fts_atom_t *at)
+{
+ paf_t *this = (paf_t *)o;
+
+ float val = fts_get_float_long_arg( at, ac, 0, 0.0f);
+ int time = fts_get_long_arg(at, ac, 1, 0);
+ pafctl_amp(&this->pafctl, val, time);
+}
+
+static void paf_vib(fts_object_t *o, int winlet, fts_symbol_t *s,
+ int ac, const fts_atom_t *at)
+{
+ paf_t *this = (paf_t *)o;
+ float val = fts_get_float_long_arg( at, ac, 0, 0.0f);
+ int time = fts_get_long_arg(at, ac, 1, 0);
+ pafctl_vib(&this->pafctl, val, time);
+}
+
+static void paf_vfr(fts_object_t *o, int winlet, fts_symbol_t *s,
+ int ac, const fts_atom_t *at)
+{
+ paf_t *this = (paf_t *)o;
+ float val = fts_get_float_long_arg( at, ac, 0, 0.0f);
+ int time = fts_get_long_arg(at, ac, 1, 0);
+ pafctl_vfr(&this->pafctl, val, time);
+}
+
+static void paf_shift(fts_object_t *o, int winlet, fts_symbol_t *s,
+ int ac, const fts_atom_t *at)
+{
+ paf_t *this = (paf_t *)o;
+ float val = fts_get_float_long_arg( at, ac, 0, 0.0f);
+ int time = fts_get_long_arg(at, ac, 1, 0);
+ pafctl_shift(&this->pafctl, val, time);
+}
+
+static void paf_phase(fts_object_t *o, int winlet, fts_symbol_t *s,
+ int ac, const fts_atom_t *at)
+{
+ paf_t *this = (paf_t *)o;
+ float phase = fts_get_float_long_arg( at, ac, 0, 0.0f);
+ float shiftphase = fts_get_long_arg(at, ac, 1, 0);
+ float vibphase = fts_get_long_arg(at, ac, 2, 0);
+ pafctl_shift(&this->pafctl, phase, shiftphase, vibphase);
+}
+
+static void
+paf_print(fts_object_t *o, int winlet, fts_symbol_t *s, int ac, const fts_atom_t *at)
+{
+}
+
+static void
+paf_init(fts_object_t *o, int winlet, fts_symbol_t *s, int ac, const fts_atom_t *at)
+{
+ paf_t *this = (paf_t *)o;
+ int i;
+
+ dsp_list_insert(o); /* put object in list */
+ pafctl_init(&this->pafctl);
+}
+
+static void paf_delete(fts_object_t *o, int winlet, fts_symbol_t *s,
+ int ac, const fts_atom_t *at)
+{
+ paf_t *this = (paf_t *)o;
+
+ dsp_list_remove(o);
+}
+
+static fts_status_t paf_instantiate( fts_class_t *cl,
+ int ac, const fts_atom_t *at)
+{
+ fts_atom_type_t a[3];
+
+ fts_class_init( cl, sizeof(paf_t), 1, 2, 0);
+
+ a[0] = fts_Symbol;
+ fts_method_define( cl, fts_SystemInlet, fts_s_init, paf_init, 1, a);
+ fts_method_define( cl, fts_SystemInlet, fts_s_delete, paf_delete, 1, a);
+
+ a[0] = fts_Float|fts_Long;
+ a[1] = fts_Long;
+ fts_method_define( cl, 0, fts_new_symbol("freq"), paf_freq, 2, a);
+ fts_method_define( cl, 0, fts_new_symbol("cf"), paf_cf, 2, a);
+ fts_method_define( cl, 0, fts_new_symbol("bw"), paf_bw, 2, a);
+ fts_method_define( cl, 0, fts_new_symbol("amp"), paf_amp, 2, a);
+ fts_method_define( cl, 0, fts_new_symbol("vib"), paf_vib, 2, a);
+ fts_method_define( cl, 0, fts_new_symbol("vfr"), paf_vfr, 2, a);
+ fts_method_define( cl, 0, fts_new_symbol("shift"), paf_shift, 2, a);
+ fts_method_define( cl, 0, fts_new_symbol("phase"), paf_phase, 3, a);
+
+ fts_method_define( cl, 0, fts_new_symbol("print"), paf_print, 0, 0);
+
+ a[0] = fts_Object;
+ fts_method_define(cl, fts_SystemInlet, fts_new_symbol("put"),
+ paf_put, 1, a);
+
+ dsp_sig_inlet(cl, 0); /* order forcing only */
+
+ dsp_sig_outlet(cl, 0);
+
+ return fts_Success;
+}
+
+fts_symbol_t *paf_qui;
+
+void paf_config(void)
+{
+ sys_log(paf_version);
+ paf_dspname = fts_new_symbol("paf");
+ dsp_declare_function(paf_dspname, paf_dspfun);
+ fts_metaclass_create(fts_new_symbol("paf"),
+ paf_instantiate, fts_always_equiv);
+ paf_dosetup();
+}
+
+fts_module_t paf_module =
+ {"paf", "paf", paf_config, 0};
+
+#endif /* FTS1X */
+
+#ifdef V26
+
+typedef struct _paf
+{
+ t_head x_h;
+ t_sig *x_io[IN1+OUT1];
+ t_pafctl x_pafctl;
+} t_paf;
+
+static void paf_put(t_paf *x, long int whether)
+{
+ if (whether)
+ {
+ float sr = x->x_io[0]->s_sr;
+ int vecsize = x->x_io[0]->s_n;
+ u_stdout((t_ugen *)x);
+ pafctl_setsr(&x->x_pafctl, sr, vecsize);
+ dspchain_addc(pafctl_run, 3,
+ &x->x_pafctl, x->x_io[1]->s_shit, x->x_io[1]->s_n);
+ }
+}
+
+static void paf_freq(t_paf *x, double val, int time)
+{
+ pafctl_freq(&x->x_pafctl, val, time);
+}
+
+static void paf_cf(t_paf *x, double val, int time)
+{
+ pafctl_cf(&x->x_pafctl, val, time);
+}
+
+static void paf_bw(t_paf *x, double val, int time)
+{
+ pafctl_bw(&x->x_pafctl, val, time);
+}
+
+static void paf_amp(t_paf *x, double val, int time)
+{
+ pafctl_amp(&x->x_pafctl, val, time);
+}
+
+static void paf_vib(t_paf *x, double val, int time)
+{
+ pafctl_vib(&x->x_pafctl, val, time);
+}
+
+static void paf_vfr(t_paf *x, double val, int time)
+{
+ pafctl_vfr(&x->x_pafctl, val, time);
+}
+
+static void paf_shift(t_paf *x, double val, int time)
+{
+ pafctl_shift(&x->x_pafctl, val, time);
+}
+
+static void paf_phase(t_paf *x, double phase, double shiftphase,
+ double vibphase)
+{
+ pafctl_phase(&x->x_pafctl, phase, shiftphase, vibphase);
+}
+
+static void paf_debug(t_paf *x)
+{
+ linenv_debug( &x->x_pafctl.x_ampenv, "amp");
+ linenv_debug(&x->x_pafctl.x_freqenv, "fre");
+}
+
+t_externclass *paf_class;
+
+static void *paf_new()
+{
+ t_paf *x = (t_paf *)obj_new(&paf_class, 0);
+ u_setup((t_ugen *)x, IN1, OUT1);
+ u_setforcer(x);
+ pafctl_init(&x->x_pafctl);
+ return (x);
+}
+
+void sigpaf_setup()
+{
+ post(paf_version);
+ c_extern(&paf_class, paf_new, u_clean,
+ gensym("paf"), sizeof(t_paf), 0, 0);
+ c_addmess(paf_put, gensym("put"), A_CANT, 0);
+ c_addmess(paf_freq, gensym("freq"), A_FLOAT, A_LONG, 0);
+ c_addmess(paf_cf, gensym("cf"), A_FLOAT, A_LONG, 0);
+ c_addmess(paf_bw, gensym("bw"), A_FLOAT, A_LONG, 0);
+ c_addmess(paf_amp, gensym("amp"), A_FLOAT, A_LONG, 0);
+ c_addmess(paf_vib, gensym("vib"), A_FLOAT, A_LONG, 0);
+ c_addmess(paf_vfr, gensym("vfr"), A_FLOAT, A_LONG, 0);
+ c_addmess(paf_shift, gensym("shift"), A_FLOAT, A_LONG, 0);
+ c_addmess(paf_phase, gensym("phase"), A_FLOAT, A_FLOAT, A_FLOAT, 0);
+ c_addmess(paf_debug, gensym("debug"), 0);
+ u_inletmethod(0);
+ paf_dosetup();
+}
+
+#endif /* V26 */
+
+#ifdef PD
+
+typedef struct _paf
+{
+ t_object x_obj;
+ t_pafctl x_pafctl;
+} t_paf;
+
+static t_class *paf_class;
+
+static void *paf_new(void)
+{
+ t_paf *x = (t_paf *)pd_new(paf_class);
+ pafctl_init(&x->x_pafctl);
+ outlet_new(&x->x_obj, gensym("signal"));
+ return (x);
+}
+
+static t_int *paf_perform(t_int *w)
+{
+ t_pafctl *ctl = (t_pafctl *)(w[1]);
+ t_float *out1 = (t_float *)(w[2]);
+ int n = (int)(w[3]);
+ pafctl_run(ctl, out1, n);
+ return (w+4);
+}
+
+static void paf_dsp(t_paf *x, t_signal **sp)
+{
+ float sr = sp[0]->s_sr;
+ int vecsize = sp[0]->s_n;
+ pafctl_setsr(&x->x_pafctl, sr, vecsize);
+ dsp_add(paf_perform, 3,
+ &x->x_pafctl, sp[0]->s_vec, sp[0]->s_n);
+}
+
+static void paf_freq(t_paf *x, t_floatarg val, t_floatarg time)
+{
+ pafctl_freq(&x->x_pafctl, val, time);
+}
+
+static void paf_cf(t_paf *x, t_floatarg val, t_floatarg time)
+{
+ pafctl_cf(&x->x_pafctl, val, time);
+}
+
+static void paf_bw(t_paf *x, t_floatarg val, t_floatarg time)
+{
+ pafctl_bw(&x->x_pafctl, val, time);
+}
+
+static void paf_amp(t_paf *x, t_floatarg val, t_floatarg time)
+{
+ pafctl_amp(&x->x_pafctl, val, time);
+}
+
+static void paf_vib(t_paf *x, t_floatarg val, t_floatarg time)
+{
+ pafctl_vib(&x->x_pafctl, val, time);
+}
+
+static void paf_vfr(t_paf *x, t_floatarg val, t_floatarg time)
+{
+ pafctl_vfr(&x->x_pafctl, val, time);
+}
+
+static void paf_shift(t_paf *x, t_floatarg val, t_floatarg time)
+{
+ pafctl_shift(&x->x_pafctl, val, time);
+}
+
+static void paf_phase(t_paf *x, t_floatarg mainphase, t_floatarg shiftphase,
+ t_floatarg vibphase)
+{
+ pafctl_phase(&x->x_pafctl, mainphase, shiftphase, vibphase);
+}
+
+static void paf_setcauchy(t_paf *x, t_floatarg f)
+{
+ x->x_pafctl.x_cauchy = (f != 0);
+}
+
+static void paf_debug(t_paf *x)
+{
+ /* whatever you want... */
+}
+
+void paf_tilde_setup(void)
+{
+ post(paf_version);
+ paf_class = class_new(gensym("paf~"), (t_newmethod)paf_new, 0,
+ sizeof(t_paf), 0, 0);
+ class_addmethod(paf_class, (t_method)paf_dsp, gensym("dsp"), A_CANT, 0);
+ class_addmethod(paf_class, (t_method)paf_freq, gensym("freq"),
+ A_FLOAT, A_DEFFLOAT, 0);
+ class_addmethod(paf_class, (t_method)paf_cf, gensym("cf"),
+ A_FLOAT, A_DEFFLOAT, 0);
+ class_addmethod(paf_class, (t_method)paf_bw, gensym("bw"),
+ A_FLOAT, A_DEFFLOAT, 0);
+ class_addmethod(paf_class, (t_method)paf_amp, gensym("amp"),
+ A_FLOAT, A_DEFFLOAT, 0);
+ class_addmethod(paf_class, (t_method)paf_vib, gensym("vib"),
+ A_FLOAT, A_DEFFLOAT, 0);
+ class_addmethod(paf_class, (t_method)paf_vfr, gensym("vfr"),
+ A_FLOAT, A_DEFFLOAT, 0);
+ class_addmethod(paf_class, (t_method)paf_shift, gensym("shift"),
+ A_FLOAT, A_DEFFLOAT, 0);
+ class_addmethod(paf_class, (t_method)paf_phase, gensym("phase"),
+ A_FLOAT, A_FLOAT, A_FLOAT, 0);
+ class_addmethod(paf_class, (t_method)paf_setcauchy, gensym("cauchy"),
+ A_FLOAT, 0);
+ class_addmethod(paf_class, (t_method)paf_debug, gensym("debug"), 0);
+ paf_dosetup();
+}
+
+#endif /* PD */
generated by cgit v1.2.1 (git 2.18.0) at 2024-12-25 08:01:40 +0000