pure-data/src/g_io.c

/* Copyright (c) 1997-1999 Miller Puckette.
* For information on usage and redistribution, and for a DISCLAIMER OF ALL
* WARRANTIES, see the file, "LICENSE.txt," in this distribution.  */

/* graphical inlets and outlets, both for control and signals.  */

/* This code is highly inefficient; messages actually have to be forwarded
by inlets and outlets.  The outlet is in even worse shape than the inlet;
in order to avoid having a "signal" method in the class, the oulet actually
sprouts an inlet, which forwards the message to the "outlet" object, which
sends it on to the outlet proper.  Another way to do it would be to have
separate classes for "signal" and "control" outlets, but this would complicate
life elsewhere. */


#include "m_pd.h"
#include "g_canvas.h"
#include <string.h>

static int symbol2resamplemethod(t_symbol*s)
{ … }

/* ------------------------- vinlet -------------------------- */
t_class *vinlet_class;

t_reblocker;

static void reblocker_init(t_reblocker *rb, int buflength)
{ … }

static void reblocker_resize(t_reblocker **rb, int oldn, int newn,
    int buflength)
{ … }

t_vinlet;

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

static void vinlet_bang(t_vinlet *x)
{ … }

static void vinlet_pointer(t_vinlet *x, t_gpointer *gp)
{ … }

static void vinlet_float(t_vinlet *x, t_float f)
{ … }

static void vinlet_symbol(t_vinlet *x, t_symbol *s)
{ … }

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

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

static void vinlet_free(t_vinlet *x)
{ … }

t_inlet *vinlet_getit(t_pd *x)
{ … }

/* ------------------------- signal inlet -------------------------- */
int vinlet_issignal(t_vinlet *x)
{ … }

t_int *vinlet_perform(t_int *w)
{ … }

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

static void vinlet_dsp(t_vinlet *x, t_signal **sp)
{ … }

    /* prolog code: loads buffer from parent patch */
t_int *vinlet_doprolog(t_int *w)
{ … }

int inlet_getsignalindex(t_inlet *x);

        /* set up prolog DSP code  */
void vinlet_dspprolog(struct _vinlet *x, t_signal **parentsigs,
    int myvecsize, int phase, int period, int frequency,
    int downsample, int upsample,  int reblock, int switched)
{ … }

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

static void vinlet_setup(void)
{ … }

/* ------------------------- voutlet -------------------------- */

t_class *voutlet_class;

t_voutlet;

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

static void voutlet_bang(t_voutlet *x)
{ … }

static void voutlet_pointer(t_voutlet *x, t_gpointer *gp)
{ … }

static void voutlet_float(t_voutlet *x, t_float f)
{ … }

static void voutlet_symbol(t_voutlet *x, t_symbol *s)
{ … }

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

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

static void voutlet_free(t_voutlet *x)
{ … }

t_outlet *voutlet_getit(t_pd *x)
{ … }

/* ------------------------- signal outlet -------------------------- */

int voutlet_issignal(t_voutlet *x)
{ … }

    /* LATER optimize for non-overlapped case where the "+=" isn't needed */
t_int *voutlet_perform(t_int *w)
{ … }

    /* epilog code for blocking: write buffer to parent patch */
static t_int *voutlet_doepilog(t_int *w)
{ … }

    /* It's dumb that we have to offer a duplicate but we don't have the
    goddam resampling buffer allocated by the time this goes on the DSP
    chain so we have to look it up dynamically. */
static t_int *voutlet_doepilog_resample(t_int *w)
{ … }

int outlet_getsignalindex(t_outlet *x);

        /* prolog for outlets -- store pointer to the outlet on the
        parent, which, if "reblock" is false, will want to refer
        back to whatever we see on our input during the "dsp" method
        called later.  */
void voutlet_dspprolog(struct _voutlet *x, t_signal **parentsigs,
    int myvecsize, int phase, int period, int frequency,
    int downsample, int upsample, int reblock, int switched)
{ … }

static void voutlet_dsp(t_voutlet *x, t_signal **sp)
{ … }

        /* set up epilog DSP code.  If we're reblocking, this is the
        time to copy the samples out to the containing object's outlets.
        If we aren't reblocking, there's nothing to do here.  */
void voutlet_dspepilog(struct _voutlet *x, t_signal **parentsigs,
    int myvecsize, int phase, int period, int frequency,
    int downsample, int upsample, int reblock, int switched)
{ … }

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


static void voutlet_setup(void)
{ … }

/* ---------------------------- overall setup ----------------------------- */

void g_io_setup(void)
{ … }