pure-data/src/d_array.c

/* 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.  */

/* reading and writing arrays */
/* LATER consider adding methods to set gpointer */

#include "m_pd.h"
#include "g_canvas.h"

    /* common struct for reading or writing to an array at DSP time. */
t_dsparray;

t_arrayvec;

    /* LATER consider exporting this and using it for tabosc4~ too */
static int dsparray_get_array(t_dsparray *d, int *npoints, t_word **vec,
    int recover)
{ … }

static void arrayvec_testvec(t_arrayvec *v)
{ … }

static void arrayvec_set(t_arrayvec *v, int argc, t_atom *argv)
{ … }

static void arrayvec_init(t_arrayvec *v, void *x, int rawargc, t_atom *rawargv)
{ … }

static void arrayvec_free(t_arrayvec *v)
{ … }

/* ------------------------- tabwrite~ -------------------------- */

static t_class *tabwrite_tilde_class;

t_tabwrite_tilde;

static void *tabwrite_tilde_new(t_symbol *s, int argc, t_atom *argv)
{ … }

static void tabwrite_tilde_redraw(t_symbol *arraysym)
{ … }

static t_int *tabwrite_tilde_perform(t_int *w)
{ … }

static void tabwrite_tilde_set(t_tabwrite_tilde *x, t_symbol *s,
    int argc, t_atom *argv)
{ … }

static void tabwrite_tilde_dsp(t_tabwrite_tilde *x, t_signal **sp)
{ … }

static void tabwrite_tilde_start(t_tabwrite_tilde *x, t_floatarg f)
{ … }

static void tabwrite_tilde_bang(t_tabwrite_tilde *x)
{ … }

static void tabwrite_tilde_stop(t_tabwrite_tilde *x)
{ … }

static void tabwrite_tilde_free(t_tabwrite_tilde *x)
{ … }

static void tabwrite_tilde_setup(void)
{ … }

/* ------------ tabplay~ - non-transposing sample playback --------------- */

static t_class *tabplay_tilde_class;

t_tabplay_tilde;

static void tabplay_tilde_tick(t_tabplay_tilde *x);

static void *tabplay_tilde_new(t_symbol *s, int argc, t_atom *argv)
{ … }

static t_int *tabplay_tilde_perform(t_int *w)
{ … }

static void tabplay_tilde_set(t_tabplay_tilde *x, t_symbol *s,
    int argc, t_atom *argv)
{ … }

static void tabplay_tilde_dsp(t_tabplay_tilde *x, t_signal **sp)
{ … }

static void tabplay_tilde_list(t_tabplay_tilde *x, t_symbol *s,
    int argc, t_atom *argv)
{ … }

static void tabplay_tilde_stop(t_tabplay_tilde *x)
{ … }

static void tabplay_tilde_tick(t_tabplay_tilde *x)
{ … }

static void tabplay_tilde_free(t_tabplay_tilde *x)
{ … }

static void tabplay_tilde_setup(void)
{ … }

/******************** tabread~ ***********************/

static t_class *tabread_tilde_class;

t_tabread_tilde;

static void *tabread_tilde_new(t_symbol *s, int argc, t_atom *argv)
{ … }

static t_int *tabread_tilde_perform(t_int *w)
{ … }

static void tabread_tilde_set(t_tabread_tilde *x, t_symbol *s,
    int argc, t_atom *argv)
{ … }

static void tabread_tilde_dsp(t_tabread_tilde *x, t_signal **sp)
{ … }

static void tabread_tilde_free(t_tabread_tilde *x)
{ … }

static void tabread_tilde_setup(void)
{ … }

/******************** tabread4~ ***********************/

static t_class *tabread4_tilde_class;

t_tabread4_tilde;

static void *tabread4_tilde_new(t_symbol *s, int argc, t_atom *argv)
{ … }

static t_int *tabread4_tilde_perform(t_int *w)
{ … }

static void tabread4_tilde_set(t_tabread4_tilde *x, t_symbol *s,
    int argc, t_atom *argv)
{ … }

static void tabread4_tilde_dsp(t_tabread4_tilde *x, t_signal **sp)
{ … }

static void tabread4_tilde_free(t_tabread4_tilde *x)
{ … }

static void tabread4_tilde_setup(void)
{ … }


/* ------------------------ tabsend~ ------------------------- */

static t_class *tabsend_class;

t_tabsend;

static void tabsend_tick(t_tabsend *x);

static void *tabsend_new(t_symbol *s, int argc, t_atom *argv)
{ … }

static t_int *tabsend_perform(t_int *w)
{ … }

static void tabsend_set(t_tabsend *x, t_symbol *s, int argc, t_atom *argv)
{ … }

static void tabsend_dsp(t_tabsend *x, t_signal **sp)
{ … }

static void tabsend_free(t_tabsend *x)
{ … }

static void tabsend_setup(void)
{ … }

/* ------------------------ tabreceive~ ------------------------- */

static t_class *tabreceive_class;

t_tabreceive;

static void *tabreceive_new(t_symbol *s, int argc, t_atom *argv)
{ … }

static t_int *tabreceive_perform(t_int *w)
{ … }

static void tabreceive_set(t_tabreceive *x, t_symbol *s,
    int argc, t_atom *argv)
{ … }

static void tabreceive_dsp(t_tabreceive *x, t_signal **sp)
{ … }

static void tabreceive_free(t_tabreceive *x)
{ … }

static void tabreceive_setup(void)
{ … }

/* ---------- tabread: control, non-interpolating ------------------------ */

static t_class *tabread_class;

t_tabread;

static void tabread_float(t_tabread *x, t_float f)
{ … }

static void tabread_set(t_tabread *x, t_symbol *s)
{ … }

static void *tabread_new(t_symbol *s)
{ … }

static void tabread_setup(void)
{ … }

/* ---------- tabread4: control, 4-point interpolation --------------- */

static t_class *tabread4_class;

t_tabread4;

static void tabread4_float(t_tabread4 *x, t_float f)
{ … }

static void tabread4_set(t_tabread4 *x, t_symbol *s)
{ … }

static void *tabread4_new(t_symbol *s)
{ … }

static void tabread4_setup(void)
{ … }

/* ------------------ tabwrite: control ------------------------ */

static t_class *tabwrite_class;

t_tabwrite;

static void tabwrite_float(t_tabwrite *x, t_float f)
{ … }

static void tabwrite_set(t_tabwrite *x, t_symbol *s)
{ … }

static void *tabwrite_new(t_symbol *s)
{ … }

void tabwrite_setup(void)
{ … }

/* ------------------------ global setup routine ------------------------- */

void d_array_setup(void)
{ … }