diff options
| -rw-r--r-- | src/makefile.linux | 5 | ||||
| -rw-r--r-- | src/z_array.c | 688 | ||||
| -rw-r--r-- | src/zexy.c | 4 |
3 files changed, 694 insertions, 3 deletions
diff --git a/src/makefile.linux b/src/makefile.linux index 37d0938..fb4e167 100644 --- a/src/makefile.linux +++ b/src/makefile.linux @@ -15,7 +15,7 @@ current: all # PD will install to $(DESTDIR)$(INSTALLL_PREFIX)$(PDLIBDIR), which is /usr/local/lib/pd # by default DESTDIR = -INSTALL_PREFIX = /usr/local +INSTALL_PREFIX = /usr PDLIBDIR = /lib/pd #these were the user adjustables @@ -36,7 +36,8 @@ TARGETS = zexy \ z_dfreq z_sigzero z_pdf \ z_sfplay z_sfrecord \ z_sigpack \ - z_prime z_random z_wrap + z_prime z_random z_wrap \ + z_array # ----------------------- LINUX ---------------------------- .SUFFIXES: .pd_linux diff --git a/src/z_array.c b/src/z_array.c new file mode 100644 index 0000000..efd22fd --- /dev/null +++ b/src/z_array.c @@ -0,0 +1,688 @@ +/* copyleft (c) 2003 forum::für::umläute -- IOhannes m zmölnig @ IEM + * based on d_array.c from pd: + * Copyright (c) 1997-1999 Miller Puckette and others. + * For information on usage and redistribution, and for a DISCLAIMER OF ALL + * WARRANTIES, see the file, "LICENSE.txt," in this distribution. */ + +/* sampling */ + +#include "m_pd.h" + +/* ------------------------- table16 -------------------------- */ +/* a 16bit table */ +static t_class *table16_class; +typedef struct _table16 { + t_object x_obj; + + t_symbol *x_tablename; + long x_size; + short *x_table; // hold the data + + int x_usedindsp; +} t_table16; + +static void *table16_new(t_symbol *s, t_float f){ + t_table16 *x = (t_table16*)pd_new(table16_class); + int i=f; + if(i<1)i=1; + x->x_tablename=s; + x->x_size=i; + x->x_table=getbytes(x->x_size*sizeof(short)); + x->x_usedindsp=0; + pd_bind(&x->x_obj.ob_pd, x->x_tablename); + return(x); +} + +static void table16_free(t_table16 *x){ + if(x->x_table)freebytes(x->x_table, x->x_size*sizeof(short)); + pd_unbind(&x->x_obj.ob_pd, x->x_tablename); +} + +static int table16_getarray16(t_table16*x, int*size,short**vec){ + *size=x->x_size; + *vec =x->x_table; + return 1; +} +static void table16_usedindsp(t_table16*x){ + x->x_usedindsp=1; +} + +static void table16_setup(void){ + table16_class = class_new(gensym("table16"), + (t_newmethod)table16_new, (t_method)table16_free, + sizeof(t_table16), 0, A_DEFSYM, A_DEFFLOAT, 0); +} + + +/* ------------------------- tab16write~ -------------------------- */ + +static t_class *tab16write_tilde_class; + +typedef struct _tab16write_tilde +{ + t_object x_obj; + int x_phase; + int x_nsampsintab; + short *x_vec; + t_symbol *x_arrayname; + float x_f; +} t_tab16write_tilde; + +static void *tab16write_tilde_new(t_symbol *s) +{ + t_tab16write_tilde *x = (t_tab16write_tilde *)pd_new(tab16write_tilde_class); + x->x_phase = 0x7fffffff; + x->x_arrayname = s; + x->x_f = 0; + return (x); +} + +static t_int *tab16write_tilde_perform(t_int *w) +{ + t_tab16write_tilde *x = (t_tab16write_tilde *)(w[1]); + t_float *in = (t_float *)(w[2]); + int n = (int)(w[3]), phase = x->x_phase, endphase = x->x_nsampsintab; + if (!x->x_vec) goto bad; + + if (endphase > phase) + { + int nxfer = endphase - phase; + short *fp = x->x_vec + phase; + if (nxfer > n) nxfer = n; + phase += nxfer; + while (nxfer--) + { + float f = *in++; + if (PD_BADFLOAT(f)) + f = 0; + *fp++ = f; + } + x->x_phase = phase; + } +bad: + return (w+4); +} + +void tab16write_tilde_set(t_tab16write_tilde *x, t_symbol *s) +{ + t_table16 *a; + + x->x_arrayname = s; + if (!(a = (t_table16 *)pd_findbyclass(x->x_arrayname, table16_class))) + { + if (*s->s_name) pd_error(x, "tab16write~: %s: no such array", + x->x_arrayname->s_name); + x->x_vec = 0; + } + else if (!table16_getarray16(a, &x->x_nsampsintab, &x->x_vec)) + { + error("%s: bad template for tab16write~", x->x_arrayname->s_name); + x->x_vec = 0; + } + else table16_usedindsp(a); +} + +static void tab16write_tilde_dsp(t_tab16write_tilde *x, t_signal **sp) +{ + tab16write_tilde_set(x, x->x_arrayname); + dsp_add(tab16write_tilde_perform, 3, x, sp[0]->s_vec, sp[0]->s_n); +} + +static void tab16write_tilde_bang(t_tab16write_tilde *x) +{ + x->x_phase = 0; +} + +static void tab16write_tilde_stop(t_tab16write_tilde *x) +{} + +static void tab16write_tilde_free(t_tab16write_tilde *x) +{} + +static void tab16write_tilde_setup(void) +{ + tab16write_tilde_class = class_new(gensym("tab16write~"), + (t_newmethod)tab16write_tilde_new, (t_method)tab16write_tilde_free, + sizeof(t_tab16write_tilde), 0, A_DEFSYM, 0); + CLASS_MAINSIGNALIN(tab16write_tilde_class, t_tab16write_tilde, x_f); + class_addmethod(tab16write_tilde_class, (t_method)tab16write_tilde_dsp, + gensym("dsp"), 0); + class_addmethod(tab16write_tilde_class, (t_method)tab16write_tilde_set, + gensym("set"), A_SYMBOL, 0); + class_addmethod(tab16write_tilde_class, (t_method)tab16write_tilde_stop, + gensym("stop"), 0); + class_addbang(tab16write_tilde_class, tab16write_tilde_bang); +} + +/* ------------ tab16play~ - non-transposing sample playback --------------- */ + +static t_class *tab16play_tilde_class; + +typedef struct _tab16play_tilde +{ + t_object x_obj; + t_outlet *x_bangout; + int x_phase; + int x_nsampsintab; + int x_limit; + short *x_vec; + t_symbol *x_arrayname; +} t_tab16play_tilde; + +static void *tab16play_tilde_new(t_symbol *s) +{ + t_tab16play_tilde *x = (t_tab16play_tilde *)pd_new(tab16play_tilde_class); + x->x_phase = 0x7fffffff; + x->x_limit = 0; + x->x_arrayname = s; + outlet_new(&x->x_obj, &s_signal); + x->x_bangout = outlet_new(&x->x_obj, &s_bang); + return (x); +} + +static t_int *tab16play_tilde_perform(t_int *w) +{ + t_tab16play_tilde *x = (t_tab16play_tilde *)(w[1]); + t_float *out = (t_float *)(w[2]); + short *fp; + int n = (int)(w[3]), phase = x->x_phase, + endphase = (x->x_nsampsintab < x->x_limit ? + x->x_nsampsintab : x->x_limit), nxfer, n3; + if (!x->x_vec || phase >= endphase) + goto zero; + + nxfer = endphase - phase; + fp = x->x_vec + phase; + if (nxfer > n) + nxfer = n; + n3 = n - nxfer; + phase += nxfer; + while (nxfer--) + *out++ = *fp++; + if (phase >= endphase) + { + x->x_phase = 0x7fffffff; + while (n3--) + *out++ = 0; + } + else x->x_phase = phase; + + return (w+4); +zero: + while (n--) *out++ = 0; + return (w+4); +} + +void tab16play_tilde_set(t_tab16play_tilde *x, t_symbol *s) +{ + t_table16 *a; + + x->x_arrayname = s; + if (!(a = (t_table16 *)pd_findbyclass(x->x_arrayname, table16_class))) + { + if (*s->s_name) pd_error(x, "tab16play~: %s: no such array", + x->x_arrayname->s_name); + x->x_vec = 0; + } + else if (!table16_getarray16(a, &x->x_nsampsintab, &x->x_vec)) + { + error("%s: bad template for tab16play~", x->x_arrayname->s_name); + x->x_vec = 0; + } + else table16_usedindsp(a); +} + +static void tab16play_tilde_dsp(t_tab16play_tilde *x, t_signal **sp) +{ + tab16play_tilde_set(x, x->x_arrayname); + dsp_add(tab16play_tilde_perform, 3, x, sp[0]->s_vec, sp[0]->s_n); +} + +static void tab16play_tilde_list(t_tab16play_tilde *x, t_symbol *s, + int argc, t_atom *argv) +{ + long start = atom_getfloatarg(0, argc, argv); + long length = atom_getfloatarg(1, argc, argv); + if (start < 0) start = 0; + if (length <= 0) + x->x_limit = 0x7fffffff; + else + x->x_limit = start + length; + x->x_phase = start; +} + +static void tab16play_tilde_stop(t_tab16play_tilde *x) +{ + x->x_phase = 0x7fffffff; +} + +static void tab16play_tilde_free(t_tab16play_tilde *x) +{} + +static void tab16play_tilde_setup(void) +{ + tab16play_tilde_class = class_new(gensym("tab16play~"), + (t_newmethod)tab16play_tilde_new, (t_method)tab16play_tilde_free, + sizeof(t_tab16play_tilde), 0, A_DEFSYM, 0); + class_addmethod(tab16play_tilde_class, (t_method)tab16play_tilde_dsp, + gensym("dsp"), 0); + class_addmethod(tab16play_tilde_class, (t_method)tab16play_tilde_stop, + gensym("stop"), 0); + class_addmethod(tab16play_tilde_class, (t_method)tab16play_tilde_set, + gensym("set"), A_DEFSYM, 0); + class_addlist(tab16play_tilde_class, tab16play_tilde_list); +} + +/******************** tab16read~ ***********************/ + +static t_class *tab16read_tilde_class; + +typedef struct _tab16read_tilde +{ + t_object x_obj; + int x_npoints; + short *x_vec; + t_symbol *x_arrayname; + float x_f; +} t_tab16read_tilde; + +static void *tab16read_tilde_new(t_symbol *s) +{ + t_tab16read_tilde *x = (t_tab16read_tilde *)pd_new(tab16read_tilde_class); + x->x_arrayname = s; + x->x_vec = 0; + outlet_new(&x->x_obj, gensym("signal")); + x->x_f = 0; + return (x); +} + +static t_int *tab16read_tilde_perform(t_int *w) +{ + t_tab16read_tilde *x = (t_tab16read_tilde *)(w[1]); + t_float *in = (t_float *)(w[2]); + t_float *out = (t_float *)(w[3]); + int n = (int)(w[4]); + int maxindex; + short *buf = x->x_vec; + int i; + + maxindex = x->x_npoints - 1; + if (!buf) goto zero; + + for (i = 0; i < n; i++) + { + int index = *in++; + if (index < 0) + index = 0; + else if (index > maxindex) + index = maxindex; + *out++ = buf[index]; + } + return (w+5); + zero: + while (n--) *out++ = 0; + + return (w+5); +} + +void tab16read_tilde_set(t_tab16read_tilde *x, t_symbol *s) +{ + t_table16 *a; + + x->x_arrayname = s; + if (!(a = (t_table16 *)pd_findbyclass(x->x_arrayname, table16_class))) + { + if (*s->s_name) + error("tab16read~: %s: no such array", x->x_arrayname->s_name); + x->x_vec = 0; + } + else if (!table16_getarray16(a, &x->x_npoints, &x->x_vec)) + { + error("%s: bad template for tab16read~", x->x_arrayname->s_name); + x->x_vec = 0; + } + else table16_usedindsp(a); +} + +static void tab16read_tilde_dsp(t_tab16read_tilde *x, t_signal **sp) +{ + tab16read_tilde_set(x, x->x_arrayname); + + dsp_add(tab16read_tilde_perform, 4, x, + sp[0]->s_vec, sp[1]->s_vec, sp[0]->s_n); + +} + +static void tab16read_tilde_free(t_tab16read_tilde *x) +{ +} + +static void tab16read_tilde_setup(void) +{ + tab16read_tilde_class = class_new(gensym("tab16read~"), + (t_newmethod)tab16read_tilde_new, (t_method)tab16read_tilde_free, + sizeof(t_tab16read_tilde), 0, A_DEFSYM, 0); + CLASS_MAINSIGNALIN(tab16read_tilde_class, t_tab16read_tilde, x_f); + class_addmethod(tab16read_tilde_class, (t_method)tab16read_tilde_dsp, + gensym("dsp"), 0); + class_addmethod(tab16read_tilde_class, (t_method)tab16read_tilde_set, + gensym("set"), A_SYMBOL, 0); +} + +/******************** tab16read4~ ***********************/ + +static t_class *tab16read4_tilde_class; + +typedef struct _tab16read4_tilde +{ + t_object x_obj; + int x_npoints; + short *x_vec; + t_symbol *x_arrayname; + float x_f; +} t_tab16read4_tilde; + +static void *tab16read4_tilde_new(t_symbol *s) +{ + t_tab16read4_tilde *x = (t_tab16read4_tilde *)pd_new(tab16read4_tilde_class); + x->x_arrayname = s; + x->x_vec = 0; + outlet_new(&x->x_obj, gensym("signal")); + x->x_f = 0; + return (x); +} + +static t_int *tab16read4_tilde_perform(t_int *w) +{ + t_tab16read4_tilde *x = (t_tab16read4_tilde *)(w[1]); + t_float *in = (t_float *)(w[2]); + t_float *out = (t_float *)(w[3]); + int n = (int)(w[4]); + int maxindex; + short *buf = x->x_vec; + short *fp; + int i; + + maxindex = x->x_npoints - 3; + + if (!buf) goto zero; + +#if 0 /* test for spam -- I'm not ready to deal with this */ + for (i = 0, xmax = 0, xmin = maxindex, fp = in1; i < n; i++, fp++) + { + float f = *in1; + if (f < xmin) xmin = f; + else if (f > xmax) xmax = f; + } + if (xmax < xmin + x->c_maxextent) xmax = xmin + x->c_maxextent; + for (i = 0, splitlo = xmin+ x->c_maxextent, splithi = xmax - x->c_maxextent, + fp = in1; i < n; i++, fp++) + { + float f = *in1; + if (f > splitlo && f < splithi) goto zero; + } +#endif + + for (i = 0; i < n; i++) + { + float findex = *in++; + int index = findex; + float frac, a, b, c, d, cminusb; + if (index < 1) + index = 1, frac = 0; + else if (index > maxindex) + index = maxindex, frac = 1; + else frac = findex - index; + fp = buf + index; + a = fp[-1]; + b = fp[0]; + c = fp[1]; + d = fp[2]; + /* if (!i && !(count++ & 1023)) + post("fp = %lx, shit = %lx, b = %f", fp, buf->b_shit, b); */ + cminusb = c-b; + *out++ = b + frac * ( + cminusb - 0.5f * (frac-1.) * ( + (a - d + 3.0f * cminusb) * frac + (b - a - cminusb) + ) + ); + } + return (w+5); + zero: + while (n--) *out++ = 0; + + return (w+5); +} + +void tab16read4_tilde_set(t_tab16read4_tilde *x, t_symbol *s) +{ + t_table16 *a; + + x->x_arrayname = s; + if (!(a = (t_table16 *)pd_findbyclass(x->x_arrayname, table16_class))) + { + if (*s->s_name) + error("tab16read4~: %s: no such array", x->x_arrayname->s_name); + x->x_vec = 0; + } + else if (!table16_getarray16(a, &x->x_npoints, &x->x_vec)) + { + error("%s: bad template for tab16read4~", x->x_arrayname->s_name); + x->x_vec = 0; + } + else table16_usedindsp(a); +} + +static void tab16read4_tilde_dsp(t_tab16read4_tilde *x, t_signal **sp) +{ + tab16read4_tilde_set(x, x->x_arrayname); + + dsp_add(tab16read4_tilde_perform, 4, x, + sp[0]->s_vec, sp[1]->s_vec, sp[0]->s_n); + +} + +static void tab16read4_tilde_free(t_tab16read4_tilde *x) +{ +} + +static void tab16read4_tilde_setup(void) +{ + tab16read4_tilde_class = class_new(gensym("tab16read4~"), + (t_newmethod)tab16read4_tilde_new, (t_method)tab16read4_tilde_free, + sizeof(t_tab16read4_tilde), 0, A_DEFSYM, 0); + CLASS_MAINSIGNALIN(tab16read4_tilde_class, t_tab16read4_tilde, x_f); + class_addmethod(tab16read4_tilde_class, (t_method)tab16read4_tilde_dsp, + gensym("dsp"), 0); + class_addmethod(tab16read4_tilde_class, (t_method)tab16read4_tilde_set, + gensym("set"), A_SYMBOL, 0); +} +/* ---------- tab16read: control, non-interpolating ------------------------ */ + +static t_class *tab16read_class; + +typedef struct _tab16read +{ + t_object x_obj; + t_symbol *x_arrayname; +} t_tab16read; + +static void tab16read_float(t_tab16read *x, t_float f) +{ + t_table16 *a; + int npoints; + short *vec; + + if (!(a = (t_table16 *)pd_findbyclass(x->x_arrayname, table16_class))) + error("%s: no such array", x->x_arrayname->s_name); + else if (!table16_getarray16(a, &npoints, &vec)) + error("%s: bad template for tab16read", x->x_arrayname->s_name); + else + { + int n = f; + if (n < 0) n = 0; + else if (n >= npoints) n = npoints - 1; + outlet_float(x->x_obj.ob_outlet, (npoints ? vec[n] : 0)); + } +} + +static void tab16read_set(t_tab16read *x, t_symbol *s) +{ + x->x_arrayname = s; +} + +static void *tab16read_new(t_symbol *s) +{ + t_tab16read *x = (t_tab16read *)pd_new(tab16read_class); + x->x_arrayname = s; + outlet_new(&x->x_obj, &s_float); + return (x); +} + +static void tab16read_setup(void) +{ + tab16read_class = class_new(gensym("tab16read"), (t_newmethod)tab16read_new, + 0, sizeof(t_tab16read), 0, A_DEFSYM, 0); + class_addfloat(tab16read_class, (t_method)tab16read_float); + class_addmethod(tab16read_class, (t_method)tab16read_set, gensym("set"), + A_SYMBOL, 0); +} + +/* ---------- tab16read4: control, non-interpolating ------------------------ */ + +static t_class *tab16read4_class; + +typedef struct _tab16read4 +{ + t_object x_obj; + t_symbol *x_arrayname; +} t_tab16read4; + +static void tab16read4_float(t_tab16read4 *x, t_float f) +{ + t_table16 *a; + int npoints; + short *vec; + + if (!(a = (t_table16 *)pd_findbyclass(x->x_arrayname, table16_class))) + error("%s: no such array", x->x_arrayname->s_name); + else if (!table16_getarray16(a, &npoints, &vec)) + error("%s: bad template for tab16read4", x->x_arrayname->s_name); + else if (npoints < 4) + outlet_float(x->x_obj.ob_outlet, 0); + else if (f <= 1) + outlet_float(x->x_obj.ob_outlet, vec[1]); + else if (f >= npoints - 2) + outlet_float(x->x_obj.ob_outlet, vec[npoints - 2]); + else + { + int n = f; + float a, b, c, d, cminusb, frac; + short *fp; + if (n >= npoints - 2) + n = npoints - 3; + fp = vec + n; + frac = f - n; + a = fp[-1]; + b = fp[0]; + c = fp[1]; + d = fp[2]; + cminusb = c-b; + outlet_float(x->x_obj.ob_outlet, b + frac * ( + cminusb - 0.5f * (frac-1.) * ( + (a - d + 3.0f * cminusb) * frac + (b - a - cminusb)))); + } +} + +static void tab16read4_set(t_tab16read4 *x, t_symbol *s) +{ + x->x_arrayname = s; +} + +static void *tab16read4_new(t_symbol *s) +{ + t_tab16read4 *x = (t_tab16read4 *)pd_new(tab16read4_class); + x->x_arrayname = s; + outlet_new(&x->x_obj, &s_float); + return (x); +} + +static void tab16read4_setup(void) +{ + tab16read4_class = class_new(gensym("tab16read4"), (t_newmethod)tab16read4_new, + 0, sizeof(t_tab16read4), 0, A_DEFSYM, 0); + class_addfloat(tab16read4_class, (t_method)tab16read4_float); + class_addmethod(tab16read4_class, (t_method)tab16read4_set, gensym("set"), + A_SYMBOL, 0); +} + +/* ------------------ tab16write: control ------------------------ */ + +static t_class *tab16write_class; + +typedef struct _tab16write +{ + t_object x_obj; + t_symbol *x_arrayname; + float x_ft1; + int x_set; +} t_tab16write; + +static void tab16write_float(t_tab16write *x, t_float f) +{ + int vecsize; + t_table16 *a; + short *vec; + + if (!(a = (t_table16 *)pd_findbyclass(x->x_arrayname, table16_class))) + error("%s: no such array", x->x_arrayname->s_name); + else if (!table16_getarray16(a, &vecsize, &vec)) + error("%s: bad template for tab16write", x->x_arrayname->s_name); + else + { + int n = x->x_ft1; + if (n < 0) n = 0; + else if (n >= vecsize) n = vecsize-1; + vec[n] = f; + } +} + +static void tab16write_set(t_tab16write *x, t_symbol *s) +{ + x->x_arrayname = s; +} + +static void tab16write_free(t_tab16write *x) +{} + +static void *tab16write_new(t_symbol *s) +{ + t_tab16write *x = (t_tab16write *)pd_new(tab16write_class); + x->x_ft1 = 0; + x->x_arrayname = s; + floatinlet_new(&x->x_obj, &x->x_ft1); + return (x); +} + +void tab16write_setup(void) +{ + tab16write_class = class_new(gensym("tab16write"), (t_newmethod)tab16write_new, + (t_method)tab16write_free, sizeof(t_tab16write), 0, A_DEFSYM, 0); + class_addfloat(tab16write_class, (t_method)tab16write_float); + class_addmethod(tab16write_class, (t_method)tab16write_set, gensym("set"), A_SYMBOL, 0); +} + +/* ------------------------ global setup routine ------------------------- */ + +void z_array_setup(void) +{ + tab16write_tilde_setup(); + tab16play_tilde_setup(); + tab16read_tilde_setup(); + tab16read4_tilde_setup(); + tab16read_setup(); + tab16read4_setup(); + tab16write_setup(); + table16_setup(); +} + @@ -204,7 +204,7 @@ void z_wrap_setup(); ... */ - +void z_array_setup(); void zexy_setup(void) { @@ -269,6 +269,8 @@ void zexy_setup(void) z_lp_setup(); #endif + z_array_setup(); + /* ************************************** */ startpost("\n\t"); for (i=0; i<28; i++) startpost("%c", HEARTSYMBOL); |