Cut the files in half and it might work better (note to self: check your tree is really clean before patching)

git-svn-id: svn://svn.rockbox.org/rockbox/trunk@21070 a1c6a512-1295-4272-9138-f99709370657

1 files changed, 0 insertions, 1074 deletions

diff --git a/apps/plugins/pdbox/PDa/src/d_array.c b/apps/plugins/pdbox/PDa/src/d_array.c
index 14ae464b0b..7139e4dc3d 100644
--- a/apps/plugins/pdbox/PDa/src/d_array.c
+++ b/apps/plugins/pdbox/PDa/src/d_array.c
@@ -1072,1077 +1072,3 @@ void d_array_setup(void)
     tabwrite_setup();
 }
 
-/* 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 */
-
-/* LATER make tabread4 and tabread~ */
-
-#include "m_pd.h"
-
-
-/* ------------------------- tabwrite~ -------------------------- */
-
-static t_class *tabwrite_tilde_class;
-
-typedef struct _tabwrite_tilde
-{
-    t_object x_obj;
-    int x_phase;
-    int x_nsampsintab;
-    float *x_vec;
-    t_symbol *x_arrayname;
-    t_clock *x_clock;
-    float x_f;
-} t_tabwrite_tilde;
-
-static void tabwrite_tilde_tick(t_tabwrite_tilde *x);
-
-static void *tabwrite_tilde_new(t_symbol *s)
-{
-    t_tabwrite_tilde *x = (t_tabwrite_tilde *)pd_new(tabwrite_tilde_class);
-    x->x_clock = clock_new(x, (t_method)tabwrite_tilde_tick);
-    x->x_phase = 0x7fffffff;
-    x->x_arrayname = s;
-    x->x_f = 0;
-    return (x);
-}
-
-static t_int *tabwrite_tilde_perform(t_int *w)
-{
-    t_tabwrite_tilde *x = (t_tabwrite_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;
-        float *fp = x->x_vec + phase;
-        if (nxfer > n) nxfer = n;
-        phase += nxfer;
-        while (nxfer--)
-        {
-            float f = *in++;
-            if (PD_BIGORSMALL(f))
-                f = 0;
-            *fp++ = f;
-        }
-        if (phase >= endphase)
-        {
-            clock_delay(x->x_clock, 0);
-            phase = 0x7fffffff;
-        }
-        x->x_phase = phase;
-    }
-bad:
-    return (w+4);
-}
-
-void tabwrite_tilde_set(t_tabwrite_tilde *x, t_symbol *s)
-{
-    t_garray *a;
-
-    x->x_arrayname = s;
-    if (!(a = (t_garray *)pd_findbyclass(x->x_arrayname, garray_class)))
-    {
-        if (*s->s_name) pd_error(x, "tabwrite~: %s: no such array",
-            x->x_arrayname->s_name);
-        x->x_vec = 0;
-    }
-    else if (!garray_getfloatarray(a, &x->x_nsampsintab, &x->x_vec))
-    {
-        pd_error(x, "%s: bad template for tabwrite~", x->x_arrayname->s_name);
-        x->x_vec = 0;
-    }
-    else garray_usedindsp(a);
-}
-
-static void tabwrite_tilde_dsp(t_tabwrite_tilde *x, t_signal **sp)
-{
-    tabwrite_tilde_set(x, x->x_arrayname);
-    dsp_add(tabwrite_tilde_perform, 3, x, sp[0]->s_vec, sp[0]->s_n);
-}
-
-static void tabwrite_tilde_bang(t_tabwrite_tilde *x)
-{
-    x->x_phase = 0;
-}
-
-static void tabwrite_tilde_stop(t_tabwrite_tilde *x)
-{
-    if (x->x_phase != 0x7fffffff)
-    {
-        tabwrite_tilde_tick(x);
-        x->x_phase = 0x7fffffff;
-    }
-}
-
-static void tabwrite_tilde_tick(t_tabwrite_tilde *x)
-{
-    t_garray *a = (t_garray *)pd_findbyclass(x->x_arrayname, garray_class);
-    if (!a) bug("tabwrite_tilde_tick");
-    else garray_redraw(a);
-}
-
-static void tabwrite_tilde_free(t_tabwrite_tilde *x)
-{
-    clock_free(x->x_clock);
-}
-
-static void tabwrite_tilde_setup(void)
-{
-    tabwrite_tilde_class = class_new(gensym("tabwrite~"),
-        (t_newmethod)tabwrite_tilde_new, (t_method)tabwrite_tilde_free,
-        sizeof(t_tabwrite_tilde), 0, A_DEFSYM, 0);
-    CLASS_MAINSIGNALIN(tabwrite_tilde_class, t_tabwrite_tilde, x_f);
-    class_addmethod(tabwrite_tilde_class, (t_method)tabwrite_tilde_dsp,
-        gensym("dsp"), 0);
-    class_addmethod(tabwrite_tilde_class, (t_method)tabwrite_tilde_set,
-        gensym("set"), A_SYMBOL, 0);
-    class_addmethod(tabwrite_tilde_class, (t_method)tabwrite_tilde_stop,
-        gensym("stop"), 0);
-    class_addbang(tabwrite_tilde_class, tabwrite_tilde_bang);
-}
-
-/* ------------ tabplay~ - non-transposing sample playback --------------- */
-
-static t_class *tabplay_tilde_class;
-
-typedef struct _tabplay_tilde
-{
-    t_object x_obj;
-    t_outlet *x_bangout;
-    int x_phase;
-    int x_nsampsintab;
-    int x_limit;
-    float *x_vec;
-    t_symbol *x_arrayname;
-    t_clock *x_clock;
-} t_tabplay_tilde;
-
-static void tabplay_tilde_tick(t_tabplay_tilde *x);
-
-static void *tabplay_tilde_new(t_symbol *s)
-{
-    t_tabplay_tilde *x = (t_tabplay_tilde *)pd_new(tabplay_tilde_class);
-    x->x_clock = clock_new(x, (t_method)tabplay_tilde_tick);
-    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 *tabplay_tilde_perform(t_int *w)
-{
-    t_tabplay_tilde *x = (t_tabplay_tilde *)(w[1]);
-    t_float *out = (t_float *)(w[2]), *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)
-    {
-        clock_delay(x->x_clock, 0);
-        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 tabplay_tilde_set(t_tabplay_tilde *x, t_symbol *s)
-{
-    t_garray *a;
-
-    x->x_arrayname = s;
-    if (!(a = (t_garray *)pd_findbyclass(x->x_arrayname, garray_class)))
-    {
-        if (*s->s_name) pd_error(x, "tabplay~: %s: no such array",
-            x->x_arrayname->s_name);
-        x->x_vec = 0;
-    }
-    else if (!garray_getfloatarray(a, &x->x_nsampsintab, &x->x_vec))
-    {
-        pd_error(x, "%s: bad template for tabplay~", x->x_arrayname->s_name);
-        x->x_vec = 0;
-    }
-    else garray_usedindsp(a);
-}
-
-static void tabplay_tilde_dsp(t_tabplay_tilde *x, t_signal **sp)
-{
-    tabplay_tilde_set(x, x->x_arrayname);
-    dsp_add(tabplay_tilde_perform, 3, x, sp[0]->s_vec, sp[0]->s_n);
-}
-
-static void tabplay_tilde_list(t_tabplay_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 tabplay_tilde_stop(t_tabplay_tilde *x)
-{
-    x->x_phase = 0x7fffffff;
-}
-
-static void tabplay_tilde_tick(t_tabplay_tilde *x)
-{
-    outlet_bang(x->x_bangout);
-}
-
-static void tabplay_tilde_free(t_tabplay_tilde *x)
-{
-    clock_free(x->x_clock);
-}
-
-static void tabplay_tilde_setup(void)
-{
-    tabplay_tilde_class = class_new(gensym("tabplay~"),
-        (t_newmethod)tabplay_tilde_new, (t_method)tabplay_tilde_free,
-        sizeof(t_tabplay_tilde), 0, A_DEFSYM, 0);
-    class_addmethod(tabplay_tilde_class, (t_method)tabplay_tilde_dsp,
-        gensym("dsp"), 0);
-    class_addmethod(tabplay_tilde_class, (t_method)tabplay_tilde_stop,
-        gensym("stop"), 0);
-    class_addmethod(tabplay_tilde_class, (t_method)tabplay_tilde_set,
-        gensym("set"), A_DEFSYM, 0);
-    class_addlist(tabplay_tilde_class, tabplay_tilde_list);
-}
-
-/******************** tabread~ ***********************/
-
-static t_class *tabread_tilde_class;
-
-typedef struct _tabread_tilde
-{
-    t_object x_obj;
-    int x_npoints;
-    float *x_vec;
-    t_symbol *x_arrayname;
-    float x_f;
-} t_tabread_tilde;
-
-static void *tabread_tilde_new(t_symbol *s)
-{
-    t_tabread_tilde *x = (t_tabread_tilde *)pd_new(tabread_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 *tabread_tilde_perform(t_int *w)
-{
-    t_tabread_tilde *x = (t_tabread_tilde *)(w[1]);
-    t_float *in = (t_float *)(w[2]);
-    t_float *out = (t_float *)(w[3]);
-    int n = (int)(w[4]);    
-    int maxindex;
-    float *buf = x->x_vec, *fp;
-    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 tabread_tilde_set(t_tabread_tilde *x, t_symbol *s)
-{
-    t_garray *a;
-    
-    x->x_arrayname = s;
-    if (!(a = (t_garray *)pd_findbyclass(x->x_arrayname, garray_class)))
-    {
-        if (*s->s_name)
-            pd_error(x, "tabread~: %s: no such array", x->x_arrayname->s_name);
-        x->x_vec = 0;
-    }
-    else if (!garray_getfloatarray(a, &x->x_npoints, &x->x_vec))
-    {
-        pd_error(x, "%s: bad template for tabread~", x->x_arrayname->s_name);
-        x->x_vec = 0;
-    }
-    else garray_usedindsp(a);
-}
-
-static void tabread_tilde_dsp(t_tabread_tilde *x, t_signal **sp)
-{
-    tabread_tilde_set(x, x->x_arrayname);
-
-    dsp_add(tabread_tilde_perform, 4, x,
-        sp[0]->s_vec, sp[1]->s_vec, sp[0]->s_n);
-
-}
-
-static void tabread_tilde_free(t_tabread_tilde *x)
-{
-}
-
-static void tabread_tilde_setup(void)
-{
-    tabread_tilde_class = class_new(gensym("tabread~"),
-        (t_newmethod)tabread_tilde_new, (t_method)tabread_tilde_free,
-        sizeof(t_tabread_tilde), 0, A_DEFSYM, 0);
-    CLASS_MAINSIGNALIN(tabread_tilde_class, t_tabread_tilde, x_f);
-    class_addmethod(tabread_tilde_class, (t_method)tabread_tilde_dsp,
-        gensym("dsp"), 0);
-    class_addmethod(tabread_tilde_class, (t_method)tabread_tilde_set,
-        gensym("set"), A_SYMBOL, 0);
-}
-
-/******************** tabread4~ ***********************/
-
-static t_class *tabread4_tilde_class;
-
-typedef struct _tabread4_tilde
-{
-    t_object x_obj;
-    int x_npoints;
-    float *x_vec;
-    t_symbol *x_arrayname;
-    float x_f;
-} t_tabread4_tilde;
-
-static void *tabread4_tilde_new(t_symbol *s)
-{
-    t_tabread4_tilde *x = (t_tabread4_tilde *)pd_new(tabread4_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 *tabread4_tilde_perform(t_int *w)
-{
-    t_tabread4_tilde *x = (t_tabread4_tilde *)(w[1]);
-    t_float *in = (t_float *)(w[2]);
-    t_float *out = (t_float *)(w[3]);
-    int n = (int)(w[4]);    
-    int maxindex;
-    float *buf = x->x_vec, *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;
-        static int count;
-        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.1666667f * (1.-frac) * (
-                (d - a - 3.0f * cminusb) * frac + (d + 2.0f*a - 3.0f*b)
-            )
-        );
-    }
-    return (w+5);
- zero:
-    while (n--) *out++ = 0;
-
-    return (w+5);
-}
-
-void tabread4_tilde_set(t_tabread4_tilde *x, t_symbol *s)
-{
-    t_garray *a;
-    
-    x->x_arrayname = s;
-    if (!(a = (t_garray *)pd_findbyclass(x->x_arrayname, garray_class)))
-    {
-        if (*s->s_name)
-            pd_error(x, "tabread4~: %s: no such array", x->x_arrayname->s_name);
-        x->x_vec = 0;
-    }
-    else if (!garray_getfloatarray(a, &x->x_npoints, &x->x_vec))
-    {
-        pd_error(x, "%s: bad template for tabread4~", x->x_arrayname->s_name);
-        x->x_vec = 0;
-    }
-    else garray_usedindsp(a);
-}
-
-static void tabread4_tilde_dsp(t_tabread4_tilde *x, t_signal **sp)
-{
-    tabread4_tilde_set(x, x->x_arrayname);
-
-    dsp_add(tabread4_tilde_perform, 4, x,
-        sp[0]->s_vec, sp[1]->s_vec, sp[0]->s_n);
-
-}
-
-static void tabread4_tilde_free(t_tabread4_tilde *x)
-{
-}
-
-static void tabread4_tilde_setup(void)
-{
-    tabread4_tilde_class = class_new(gensym("tabread4~"),
-        (t_newmethod)tabread4_tilde_new, (t_method)tabread4_tilde_free,
-        sizeof(t_tabread4_tilde), 0, A_DEFSYM, 0);
-    CLASS_MAINSIGNALIN(tabread4_tilde_class, t_tabread4_tilde, x_f);
-    class_addmethod(tabread4_tilde_class, (t_method)tabread4_tilde_dsp,
-        gensym("dsp"), 0);
-    class_addmethod(tabread4_tilde_class, (t_method)tabread4_tilde_set,
-        gensym("set"), A_SYMBOL, 0);
-}
-
-/******************** tabosc4~ ***********************/
-
-/* this is all copied from d_osc.c... what include file could this go in? */
-#define UNITBIT32 1572864.  /* 3*2^19; bit 32 has place value 1 */
-
-    /* machine-dependent definitions.  These ifdefs really
-    should have been by CPU type and not by operating system! */
-#ifdef IRIX
-    /* big-endian.  Most significant byte is at low address in memory */
-#define HIOFFSET 0    /* word offset to find MSB */
-#define LOWOFFSET 1    /* word offset to find LSB */
-#define int32 long  /* a data type that has 32 bits */
-#else
-#ifdef MSW
-    /* little-endian; most significant byte is at highest address */
-#define HIOFFSET 1
-#define LOWOFFSET 0
-#define int32 long
-#else
-#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
-#endif
-
-#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 int32_t
-
-#else
-#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 */
-
-#endif /* MACOSX */
-#endif /* __linux__ */
-#endif /* MSW */
-#endif /* SGI */
-
-union tabfudge
-{
-    double tf_d;
-    int32 tf_i[2];
-};
-
-static t_class *tabosc4_tilde_class;
-
-typedef struct _tabosc4_tilde
-{
-    t_object x_obj;
-    float x_fnpoints;
-    float x_finvnpoints;
-    float *x_vec;
-    t_symbol *x_arrayname;
-    float x_f;
-    double x_phase;
-    float x_conv;
-} t_tabosc4_tilde;
-
-static void *tabosc4_tilde_new(t_symbol *s)
-{
-    t_tabosc4_tilde *x = (t_tabosc4_tilde *)pd_new(tabosc4_tilde_class);
-    x->x_arrayname = s;
-    x->x_vec = 0;
-    x->x_fnpoints = 512.;
-    x->x_finvnpoints = (1./512.);
-    outlet_new(&x->x_obj, gensym("signal"));
-    inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_float, gensym("ft1"));
-    x->x_f = 0;
-    return (x);
-}
-
-static t_int *tabosc4_tilde_perform(t_int *w)
-{
-    t_tabosc4_tilde *x = (t_tabosc4_tilde *)(w[1]);
-    t_float *in = (t_float *)(w[2]);
-    t_float *out = (t_float *)(w[3]);
-    int n = (int)(w[4]);
-    int normhipart;
-    union tabfudge tf;
-    float fnpoints = x->x_fnpoints;
-    int mask = fnpoints - 1;
-    float conv = fnpoints * x->x_conv;
-    int maxindex;
-    float *tab = x->x_vec, *addr;
-    int i;
-    double dphase = fnpoints * x->x_phase + UNITBIT32;
-
-    if (!tab) goto zero;
-    tf.tf_d = UNITBIT32;
-    normhipart = tf.tf_i[HIOFFSET];
-
-#if 1
-    while (n--)
-    {
-        float frac,  a,  b,  c,  d, cminusb;
-        tf.tf_d = dphase;
-        dphase += *in++ * conv;
-        addr = tab + (tf.tf_i[HIOFFSET] & mask);
-        tf.tf_i[HIOFFSET] = normhipart;
-        frac = tf.tf_d - UNITBIT32;
-        a = addr[0];
-        b = addr[1];
-        c = addr[2];
-        d = addr[3];
-        cminusb = c-b;
-        *out++ = b + frac * (
-            cminusb - 0.1666667f * (1.-frac) * (
-                (d - a - 3.0f * cminusb) * frac + (d + 2.0f*a - 3.0f*b)
-            )
-        );
-    }
-#endif
-
-    tf.tf_d = UNITBIT32 * fnpoints;
-    normhipart = tf.tf_i[HIOFFSET];
-    tf.tf_d = dphase + (UNITBIT32 * fnpoints - UNITBIT32);
-    tf.tf_i[HIOFFSET] = normhipart;
-    x->x_phase = (tf.tf_d - UNITBIT32 * fnpoints)  * x->x_finvnpoints;
-    return (w+5);
- zero:
-    while (n--) *out++ = 0;
-
-    return (w+5);
-}
-
-void tabosc4_tilde_set(t_tabosc4_tilde *x, t_symbol *s)
-{
-    t_garray *a;
-    int npoints, pointsinarray;
-
-    x->x_arrayname = s;
-    if (!(a = (t_garray *)pd_findbyclass(x->x_arrayname, garray_class)))
-    {
-        if (*s->s_name)
-            pd_error(x, "tabosc4~: %s: no such array", x->x_arrayname->s_name);
-        x->x_vec = 0;
-    }
-    else if (!garray_getfloatarray(a, &pointsinarray, &x->x_vec))
-    {
-        pd_error(x, "%s: bad template for tabosc4~", x->x_arrayname->s_name);
-        x->x_vec = 0;
-    }
-    else if ((npoints = pointsinarray - 3) != (1 << ilog2(pointsinarray - 3)))
-    {
-        pd_error(x, "%s: number of points (%d) not a power of 2 plus three",
-            x->x_arrayname->s_name, pointsinarray);
-        x->x_vec = 0;
-        garray_usedindsp(a);
-    }
-    else
-    {
-        x->x_fnpoints = npoints;
-        x->x_finvnpoints = 1./npoints;
-        garray_usedindsp(a);
-    }
-}
-
-static void tabosc4_tilde_ft1(t_tabosc4_tilde *x, t_float f)
-{
-    x->x_phase = f;
-}
-
-static void tabosc4_tilde_dsp(t_tabosc4_tilde *x, t_signal **sp)
-{
-    x->x_conv = 1. / sp[0]->s_sr;
-    tabosc4_tilde_set(x, x->x_arrayname);
-
-    dsp_add(tabosc4_tilde_perform, 4, x,
-        sp[0]->s_vec, sp[1]->s_vec, sp[0]->s_n);
-}
-
-static void tabosc4_tilde_setup(void)
-{
-    tabosc4_tilde_class = class_new(gensym("tabosc4~"),
-        (t_newmethod)tabosc4_tilde_new, 0,
-        sizeof(t_tabosc4_tilde), 0, A_DEFSYM, 0);
-    CLASS_MAINSIGNALIN(tabosc4_tilde_class, t_tabosc4_tilde, x_f);
-    class_addmethod(tabosc4_tilde_class, (t_method)tabosc4_tilde_dsp,
-        gensym("dsp"), 0);
-    class_addmethod(tabosc4_tilde_class, (t_method)tabosc4_tilde_set,
-        gensym("set"), A_SYMBOL, 0);
-    class_addmethod(tabosc4_tilde_class, (t_method)tabosc4_tilde_ft1,
-        gensym("ft1"), A_FLOAT, 0);
-}
-
-/* ------------------------ tabsend~ ------------------------- */
-
-static t_class *tabsend_class;
-
-typedef struct _tabsend
-{
-    t_object x_obj;
-    float *x_vec;
-    int x_graphperiod;
-    int x_graphcount;
-    t_symbol *x_arrayname;
-    t_clock *x_clock;
-    float x_f;
-} t_tabsend;
-
-static void tabsend_tick(t_tabsend *x);
-
-static void *tabsend_new(t_symbol *s)
-{
-    t_tabsend *x = (t_tabsend *)pd_new(tabsend_class);
-    x->x_graphcount = 0;
-    x->x_arrayname = s;
-    x->x_clock = clock_new(x, (t_method)tabsend_tick);
-    x->x_f = 0;
-    return (x);
-}
-
-static t_int *tabsend_perform(t_int *w)
-{
-    t_tabsend *x = (t_tabsend *)(w[1]);
-    t_float *in = (t_float *)(w[2]);
-    int n = w[3];
-    t_float *dest = x->x_vec;
-    int i = x->x_graphcount;
-    if (!x->x_vec) goto bad;
-
-    while (n--)
-    {   
-        float f = *in++;
-        if (PD_BIGORSMALL(f))
-            f = 0;
-         *dest++ = f;
-    }
-    if (!i--)
-    {
-        clock_delay(x->x_clock, 0);
-        i = x->x_graphperiod;
-    }
-    x->x_graphcount = i;
-bad:
-    return (w+4);
-}
-
-static void tabsend_dsp(t_tabsend *x, t_signal **sp)
-{
-    int i, vecsize;
-    t_garray *a;
-
-    if (!(a = (t_garray *)pd_findbyclass(x->x_arrayname, garray_class)))
-    {
-        if (*x->x_arrayname->s_name)
-            pd_error(x, "tabsend~: %s: no such array", x->x_arrayname->s_name);
-    }
-    else if (!garray_getfloatarray(a, &vecsize, &x->x_vec))
-        pd_error(x, "%s: bad template for tabsend~", x->x_arrayname->s_name);
-    else
-    {
-        int n = sp[0]->s_n;
-        int ticksper = sp[0]->s_sr/n;
-        if (ticksper < 1) ticksper = 1;
-        x->x_graphperiod = ticksper;
-        if (x->x_graphcount > ticksper) x->x_graphcount = ticksper;
-        if (n < vecsize) vecsize = n;
-        garray_usedindsp(a);
-        dsp_add(tabsend_perform, 3, x, sp[0]->s_vec, vecsize);
-    }
-}
-
-static void tabsend_tick(t_tabsend *x)
-{
-    t_garray *a = (t_garray *)pd_findbyclass(x->x_arrayname, garray_class);
-    if (!a) bug("tabsend_tick");
-    else garray_redraw(a);
-}
-
-static void tabsend_free(t_tabsend *x)
-{
-    clock_free(x->x_clock);
-}
-
-static void tabsend_setup(void)
-{
-    tabsend_class = class_new(gensym("tabsend~"), (t_newmethod)tabsend_new,
-        (t_method)tabsend_free, sizeof(t_tabsend), 0, A_DEFSYM, 0);
-    CLASS_MAINSIGNALIN(tabsend_class, t_tabsend, x_f);
-    class_addmethod(tabsend_class, (t_method)tabsend_dsp, gensym("dsp"), 0);
-}
-
-/* ------------------------ tabreceive~ ------------------------- */
-
-static t_class *tabreceive_class;
-
-typedef struct _tabreceive
-{
-    t_object x_obj;
-    float *x_vec;
-    t_symbol *x_arrayname;
-} t_tabreceive;
-
-static t_int *tabreceive_perform(t_int *w)
-{
-    t_tabreceive *x = (t_tabreceive *)(w[1]);
-    t_float *out = (t_float *)(w[2]);
-    int n = w[3];
-    t_float *from = x->x_vec;
-    if (from) while (n--) *out++ = *from++;
-    else while (n--) *out++ = 0;
-    return (w+4);
-}
-
-static void tabreceive_dsp(t_tabreceive *x, t_signal **sp)
-{
-    t_garray *a;
-    int vecsize;
-    
-    if (!(a = (t_garray *)pd_findbyclass(x->x_arrayname, garray_class)))
-    {
-        if (*x->x_arrayname->s_name)
-            pd_error(x, "tabsend~: %s: no such array", x->x_arrayname->s_name);
-    }
-    else if (!garray_getfloatarray(a, &vecsize, &x->x_vec))
-        pd_error(x, "%s: bad template for tabreceive~", x->x_arrayname->s_name);
-    else 
-    {
-        int n = sp[0]->s_n;
-        if (n < vecsize) vecsize = n;
-        garray_usedindsp(a);
-        dsp_add(tabreceive_perform, 3, x, sp[0]->s_vec, vecsize);
-    }
-}
-
-static void *tabreceive_new(t_symbol *s)
-{
-    t_tabreceive *x = (t_tabreceive *)pd_new(tabreceive_class);
-    x->x_arrayname = s;
-    outlet_new(&x->x_obj, &s_signal);
-    return (x);
-}
-
-static void tabreceive_setup(void)
-{
-    tabreceive_class = class_new(gensym("tabreceive~"),
-        (t_newmethod)tabreceive_new, 0,
-        sizeof(t_tabreceive), 0, A_DEFSYM, 0);
-    class_addmethod(tabreceive_class, (t_method)tabreceive_dsp,
-        gensym("dsp"), 0);
-}
-
-
-/* ---------- tabread: control, non-interpolating ------------------------ */
-
-static t_class *tabread_class;
-
-typedef struct _tabread
-{
-    t_object x_obj;
-    t_symbol *x_arrayname;
-} t_tabread;
-
-static void tabread_float(t_tabread *x, t_float f)
-{
-    t_garray *a;
-    int npoints;
-    t_float *vec;
-
-    if (!(a = (t_garray *)pd_findbyclass(x->x_arrayname, garray_class)))
-        pd_error(x, "%s: no such array", x->x_arrayname->s_name);
-    else if (!garray_getfloatarray(a, &npoints, &vec))
-        pd_error(x, "%s: bad template for tabread", 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 tabread_set(t_tabread *x, t_symbol *s)
-{
-    x->x_arrayname = s;
-}
-
-static void *tabread_new(t_symbol *s)
-{
-    t_tabread *x = (t_tabread *)pd_new(tabread_class);
-    x->x_arrayname = s;
-    outlet_new(&x->x_obj, &s_float);
-    return (x);
-}
-
-static void tabread_setup(void)
-{
-    tabread_class = class_new(gensym("tabread"), (t_newmethod)tabread_new,
-        0, sizeof(t_tabread), 0, A_DEFSYM, 0);
-    class_addfloat(tabread_class, (t_method)tabread_float);
-    class_addmethod(tabread_class, (t_method)tabread_set, gensym("set"),
-        A_SYMBOL, 0);
-}
-
-/* ---------- tabread4: control, non-interpolating ------------------------ */
-
-static t_class *tabread4_class;
-
-typedef struct _tabread4
-{
-    t_object x_obj;
-    t_symbol *x_arrayname;
-} t_tabread4;
-
-static void tabread4_float(t_tabread4 *x, t_float f)
-{
-    t_garray *a;
-    int npoints;
-    t_float *vec;
-
-    if (!(a = (t_garray *)pd_findbyclass(x->x_arrayname, garray_class)))
-        pd_error(x, "%s: no such array", x->x_arrayname->s_name);
-    else if (!garray_getfloatarray(a, &npoints, &vec))
-        pd_error(x, "%s: bad template for tabread4", 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, *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.1666667f * (1.-frac) * (
-                (d - a - 3.0f * cminusb) * frac + (d + 2.0f*a - 3.0f*b))));
-    }
-}
-
-static void tabread4_set(t_tabread4 *x, t_symbol *s)
-{
-    x->x_arrayname = s;
-}
-
-static void *tabread4_new(t_symbol *s)
-{
-    t_tabread4 *x = (t_tabread4 *)pd_new(tabread4_class);
-    x->x_arrayname = s;
-    outlet_new(&x->x_obj, &s_float);
-    return (x);
-}
-
-static void tabread4_setup(void)
-{
-    tabread4_class = class_new(gensym("tabread4"), (t_newmethod)tabread4_new,
-        0, sizeof(t_tabread4), 0, A_DEFSYM, 0);
-    class_addfloat(tabread4_class, (t_method)tabread4_float);
-    class_addmethod(tabread4_class, (t_method)tabread4_set, gensym("set"),
-        A_SYMBOL, 0);
-}
-
-/* ------------------ tabwrite: control ------------------------ */
-
-static t_class *tabwrite_class;
-
-typedef struct _tabwrite
-{
-    t_object x_obj;
-    t_symbol *x_arrayname;
-    t_clock *x_clock;
-    float x_ft1;
-    double x_updtime;
-    int x_set;
-} t_tabwrite;
-
-static void tabwrite_tick(t_tabwrite *x)
-{
-    t_garray *a = (t_garray *)pd_findbyclass(x->x_arrayname, garray_class);
-    if (!a) bug("tabwrite_tick");
-    else garray_redraw(a);
-    x->x_set = 0;
-    x->x_updtime = clock_getsystime();
-}
-
-static void tabwrite_float(t_tabwrite *x, t_float f)
-{
-    int i, vecsize;
-    t_garray *a;
-    t_float *vec;
-
-    if (!(a = (t_garray *)pd_findbyclass(x->x_arrayname, garray_class)))
-        pd_error(x, "%s: no such array", x->x_arrayname->s_name);
-    else if (!garray_getfloatarray(a, &vecsize, &vec))
-        pd_error(x, "%s: bad template for tabwrite", x->x_arrayname->s_name);
-    else
-    {
-        int n = x->x_ft1;
-        double timesince = clock_gettimesince(x->x_updtime);
-        if (n < 0) n = 0;
-        else if (n >= vecsize) n = vecsize-1;
-        vec[n] = f;
-        if (timesince > 1000)
-        {
-            tabwrite_tick(x);
-        }
-        else
-        {
-            if (x->x_set == 0)
-            {
-                clock_delay(x->x_clock, 1000 - timesince);
-                x->x_set = 1;
-            }
-        }
-    }
-}
-
-static void tabwrite_set(t_tabwrite *x, t_symbol *s)
-{
-    x->x_arrayname = s;
-}
-
-static void tabwrite_free(t_tabwrite *x)
-{
-    clock_free(x->x_clock);
-}
-
-static void *tabwrite_new(t_symbol *s)
-{
-    t_tabwrite *x = (t_tabwrite *)pd_new(tabwrite_class);
-    x->x_ft1 = 0;
-    x->x_arrayname = s;
-    x->x_updtime = clock_getsystime();
-    x->x_clock = clock_new(x, (t_method)tabwrite_tick);
-    floatinlet_new(&x->x_obj, &x->x_ft1);
-    return (x);
-}
-
-void tabwrite_setup(void)
-{
-    tabwrite_class = class_new(gensym("tabwrite"), (t_newmethod)tabwrite_new,
-        (t_method)tabwrite_free, sizeof(t_tabwrite), 0, A_DEFSYM, 0);
-    class_addfloat(tabwrite_class, (t_method)tabwrite_float);
-    class_addmethod(tabwrite_class, (t_method)tabwrite_set, gensym("set"), A_SYMBOL, 0);
-}
-
-/* ------------------------ global setup routine ------------------------- */
-
-void d_array_setup(void)
-{
-    tabwrite_tilde_setup();
-    tabplay_tilde_setup();
-    tabread_tilde_setup();
-    tabread4_tilde_setup();
-    tabosc4_tilde_setup();
-    tabsend_setup();
-    tabreceive_setup();
-    tabread_setup();
-    tabread4_setup();
-    tabwrite_setup();
-}
-