aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorN.N. <krzyszcz@users.sourceforge.net>2007-08-10 09:08:08 +0000
committerN.N. <krzyszcz@users.sourceforge.net>2007-08-10 09:08:08 +0000
commit611b5933372343af0a50da738e83e37669ccda2f (patch)
treef8b77a2f5aeb160909dd2dfe79e99f64b99de876
parent54da12a219a788142e0a81d1855f04293aa60022 (diff)
*** empty log message ***
svn path=/trunk/externals/miXed/; revision=8501
-rw-r--r--riddle/rdremote.c814
-rw-r--r--riddle/riddle.c1317
-rw-r--r--riddle/riddle.h131
-rw-r--r--riddle/riddleguts.h35
4 files changed, 1449 insertions, 848 deletions
diff --git a/riddle/rdremote.c b/riddle/rdremote.c
new file mode 100644
index 0000000..689e079
--- /dev/null
+++ b/riddle/rdremote.c
@@ -0,0 +1,814 @@
+/* Copyright (c) 2007 krzYszcz and others.
+ * For information on usage and redistribution, and for a DISCLAIMER OF ALL
+ * WARRANTIES, see the file, "LICENSE.txt," in this distribution. */
+
+#include <stdio.h>
+#include <stdarg.h>
+#include <string.h>
+#include <math.h>
+#include "m_pd.h"
+#include "common/loud.h"
+#include "common/grow.h"
+#include "sickle/sic.h"
+#include "riddle.h"
+#include "riddleguts.h"
+
+/* obj_starttraverseoutlet, obj_nexttraverseoutlet, obj_noutlets,
+ obj_nsiginlets, obj_nsigoutlets, obj_siginletindex, obj_sigoutletindex,
+ obj_issignalinlet, obj_issignaloutlet */
+#include "m_imp.h"
+
+/* struct _glist, canvas_class, vinlet_class */
+#include "g_canvas.h"
+
+EXTERN_STRUCT _rdpool;
+#define t_rdpool struct _rdpool
+
+typedef struct _rdenvironment
+{
+ t_pd en_pd;
+ t_rdpool *en_graphpools;
+ t_rdremote *en_writers;
+ t_rdremote *en_readers; /* list of orphaned readers */
+ t_clock *en_updatedspclock;
+} t_rdenvironment;
+
+static t_class *rdenvironment_class = 0;
+
+#define RDREMOTE_INISIZE 1024
+
+struct _rdremote
+{
+ int re_id; /* positive for readers, otherwise zero */
+ t_symbol *re_name;
+ t_riddle *re_owner;
+ int re_phase;
+ t_rdremote *re_portlink; /* slist of object i/o */
+ t_rdremote *re_prev; /* double-linked list of readers or writers */
+ t_rdremote *re_next;
+
+ /* common part, copied from writer to all its readers
+ immediately after any change */
+ int re_nframes;
+ int re_framesize;
+ int re_npoints;
+ int re_maxphase;
+ t_float *re_data;
+
+ /* writer-specific part */
+ t_rdremote *re_readers;
+ int re_datasize;
+ t_float *re_inidata;
+};
+
+#define RDPICKER_INISIZE 64
+
+struct _rdpool
+{
+ t_canvas *po_graph;
+ int po_refcount;
+ t_rdpicker *po_pickstore;
+ t_rdpool *po_prev;
+ t_rdpool *po_next;
+};
+
+struct _rdpicker
+{
+ t_symbol *pi_key;
+ int pi_refcount;
+ t_rdpool *pi_graphpool;
+ int pi_size;
+ int pi_maxsize;
+ t_float *pi_data;
+ t_float pi_inidata[RDPICKER_INISIZE];
+ t_rdpicker *pi_prev;
+ t_rdpicker *pi_next;
+};
+
+typedef struct _rdfeeder
+{
+ t_rdpicker *fe_picker;
+ struct _rdfeeder *fe_next;
+} t_rdfeeder;
+
+struct _rdfeedchain
+{
+ t_rdfeeder *ch_head;
+ int ch_outno;
+};
+
+static t_symbol *rdps__idle = 0;
+
+static void rdenvironment_updatedsptick(t_rdenvironment *en)
+{
+ canvas_update_dsp();
+}
+
+static void rdenvironment_anything(t_rdenvironment *en,
+ t_symbol *s, int ac, t_atom *av)
+{
+ /* FIXME */
+}
+
+static t_rdenvironment *rdenvironment_provide(void)
+{
+ t_rdenvironment *en;
+ t_symbol *ps__riddle = gensym("_riddle"); /* class name */
+ t_symbol *ps_hashriddle = gensym("#riddle"); /* instance binding */
+ if (ps_hashriddle->s_thing)
+ {
+ char *cname = class_getname(*ps_hashriddle->s_thing);
+ if (strcmp(cname, ps__riddle->s_name))
+ {
+ /* FIXME protect against the danger of someone else
+ (e.g. receive) binding to #riddle */
+ loudbug_bug("rdenvironment_provide");
+ }
+ else
+ {
+ /* FIXME compatibility test */
+ rdenvironment_class = *ps_hashriddle->s_thing;
+ return ((t_rdenvironment *)ps_hashriddle->s_thing);
+ }
+ }
+ rdps__idle = gensym("_idle");
+ rdenvironment_class = class_new(ps__riddle, 0, 0,
+ sizeof(t_rdenvironment),
+ CLASS_PD | CLASS_NOINLET, 0);
+ class_addanything(rdenvironment_class, rdenvironment_anything);
+ en = (t_rdenvironment *)pd_new(rdenvironment_class); /* never freed */
+ en->en_graphpools = 0;
+ en->en_writers = 0;
+ en->en_readers = 0;
+ en->en_updatedspclock =
+ clock_new(en, (t_method)rdenvironment_updatedsptick);
+ pd_bind((t_pd *)en, ps_hashriddle); /* never unbound */
+ return (en);
+}
+
+t_pd *riddle_getenvironment(void)
+{
+ return ((t_pd *)rdenvironment_provide());
+}
+
+
+/* subgraph-localized remote connections: feeders and pickers
+ LATER should become a kind of rdremote writers and readers */
+
+t_rdpicker *rdpicker_attach(t_riddle *rd, t_symbol *key)
+{
+ t_rdenvironment *en = rdenvironment_provide();
+ /* FIXME protect against calling outside of the constructor */
+ t_canvas *graph = canvas_getcurrent();
+ t_rdpool *po;
+ t_rdpicker *pi;
+ for (po = en->en_graphpools; po; po = po->po_next)
+ {
+ if (po->po_graph == graph)
+ {
+ for (pi = po->po_pickstore; pi; pi = pi->pi_next)
+ {
+ if (pi->pi_key == key)
+ {
+ pi->pi_refcount++;
+ return (pi);
+ }
+ }
+ }
+ }
+
+ if (po)
+ po->po_refcount++;
+ else
+ {
+ po = getbytes(sizeof(*po));
+ po->po_graph = graph;
+ po->po_refcount = 1;
+ po->po_pickstore = 0;
+ po->po_prev = 0;
+ if (en->en_graphpools)
+ en->en_graphpools->po_prev = po;
+ po->po_next = en->en_graphpools;
+ en->en_graphpools = po;
+ }
+
+ pi = getbytes(sizeof(*pi));
+ pi->pi_key = key;
+ pi->pi_refcount = 1;
+ pi->pi_graphpool = po;
+ pi->pi_size = 0;
+ pi->pi_maxsize = RDPICKER_INISIZE;
+ pi->pi_data = pi->pi_inidata;
+ pi->pi_prev = 0;
+ if (po->po_pickstore)
+ po->po_pickstore->pi_prev = pi;
+ pi->pi_next = po->po_pickstore;
+ po->po_pickstore = pi;
+ return (pi);
+}
+
+void rdpicker_detach(t_rdpicker *pi, t_riddle *rd)
+{
+ if (pi->pi_refcount > 1)
+ pi->pi_refcount--;
+ else
+ {
+ if (pi->pi_data && pi->pi_data != pi->pi_inidata)
+ freebytes(pi->pi_data, pi->pi_maxsize * sizeof(*pi->pi_data));
+ if (pi->pi_prev)
+ pi->pi_prev->pi_next = pi->pi_next;
+ else if (pi->pi_graphpool)
+ pi->pi_graphpool->po_pickstore = pi->pi_next;
+ else
+ loudbug_bug("rdpicker_detach 1");
+ if (pi->pi_next)
+ pi->pi_next->pi_prev = pi->pi_prev;
+ if (pi->pi_graphpool)
+ {
+ t_rdpool *po = pi->pi_graphpool;
+ t_rdenvironment *en = rdenvironment_provide();
+ if (po->po_refcount > 1)
+ po->po_refcount--;
+ else
+ {
+ if (po->po_pickstore)
+ loudbug_bug("rdpicker_detach 2");
+ if (po->po_prev)
+ po->po_prev->po_next = po->po_next;
+ else
+ en->en_graphpools = po->po_next;
+ if (po->po_next)
+ po->po_next->po_prev = po->po_prev;
+ freebytes(po, sizeof(*po));
+ }
+ }
+ freebytes(pi, sizeof(*pi));
+ }
+}
+
+t_float *rdpicker_pick(t_rdpicker *pi, int *sizep)
+{
+ *sizep = pi->pi_size;
+ return (pi->pi_data);
+}
+
+t_float rdpicker_pick1(t_rdpicker *pi)
+{
+ return (*pi->pi_data);
+}
+
+static t_rdpicker *rdpool_linkpicker(t_rdpool *po, t_symbol *key, int size)
+{
+ t_rdpicker *pi;
+ for (pi = po->po_pickstore; pi; pi = pi->pi_next)
+ {
+ if (pi->pi_key == key)
+ {
+ if (size > pi->pi_maxsize)
+ pi->pi_data = grow_nodata(&size, &pi->pi_maxsize, pi->pi_data,
+ RDPICKER_INISIZE, pi->pi_inidata,
+ sizeof(*pi->pi_data));
+ pi->pi_size = size;
+ return (pi);
+ }
+ }
+ return (0);
+}
+
+/* LATER think about rdpool_unlinkpicker() */
+
+static void rdfeedchain_proliferate(t_rdfeedchain *ch, t_rdpool *pohead,
+ t_gobj *g, t_symbol *key, int size)
+{
+ int result = 0;
+ for (; g; g = g->g_next)
+ {
+ if (pd_class((t_pd *)g) == canvas_class)
+ {
+ t_canvas *graph = (t_canvas *)g;
+ t_rdpool *po;
+ t_rdpicker *pi;
+ for (po = pohead; po; po = po->po_next)
+ if (po->po_graph == graph)
+ break;
+ if (po && (pi = rdpool_linkpicker(po, key, size)))
+ {
+ t_rdfeeder *fe = getbytes(sizeof(*fe)); /* FIXME reuse */
+ fe->fe_picker = pi;
+ fe->fe_next = ch->ch_head;
+ ch->ch_head = fe;
+ }
+ rdfeedchain_proliferate(ch, pohead, graph->gl_list, key, size);
+ }
+ }
+}
+
+void rdfeedchain_free(t_rdfeedchain *ch)
+{
+ t_rdfeeder *fe, *fenext;
+ for (fe = ch->ch_head; fe; fe = fenext)
+ {
+ fenext = fe->fe_next;
+ freebytes(fe, sizeof(*fe));
+ }
+}
+
+t_rdfeedchain *rdfeedchain_new(int outno)
+{
+ t_rdfeedchain *ch = getbytes(sizeof(*ch));
+ ch->ch_head = 0;
+ ch->ch_outno = outno;
+}
+
+t_rdfeedchain *riddle_usefeedchain(t_riddle *rd,
+ int sigoutno, t_symbol *key, int size)
+{
+ t_rdfeedchain *ch;
+ if (ch = riddle_getfeedchain(rd, sigoutno))
+ {
+ t_canvas *graph;
+ t_rdfeeder *fe, *fenext;
+ /* LATER reuse */
+ for (fe = ch->ch_head; fe; fe = fenext)
+ {
+ fenext = fe->fe_next;
+ freebytes(fe, sizeof(*fe));
+ }
+ for (graph = riddle_firstgraph(rd, ch->ch_outno);
+ graph; graph = riddle_nextgraph(rd))
+ {
+ t_rdenvironment *en = rdenvironment_provide();
+ t_rdpool *po;
+ t_rdpicker *pi;
+ for (po = en->en_graphpools; po; po = po->po_next)
+ if (po->po_graph == graph)
+ break;
+ if (po && (pi = rdpool_linkpicker(po, key, size)))
+ {
+ t_rdfeeder *fe = getbytes(sizeof(*fe));
+ fe->fe_picker = pi;
+ fe->fe_next = 0;
+ ch->ch_head = fe;
+ }
+ else ch->ch_head = 0;
+ rdfeedchain_proliferate(ch, en->en_graphpools,
+ (t_gobj *)graph, key, size);
+ }
+ }
+ return (ch);
+}
+
+t_rdfeedchain *riddle_useidlechain(t_riddle *rd, int sigoutno)
+{
+ return (riddle_usefeedchain(rd, sigoutno, rdps__idle, 1));
+}
+
+void rdfeedchain_feed(t_rdfeedchain *ch, int size, t_float *data)
+{
+ t_rdfeeder *fe;
+ for (fe = ch->ch_head; fe; fe = fe->fe_next)
+ {
+ t_rdpicker *pi = fe->fe_picker;
+ if (size > pi->pi_size)
+ size = pi->pi_size;
+ memcpy(pi->pi_data, data, size * sizeof(*pi->pi_data));
+ }
+}
+
+void rdfeedchain_feed1(t_rdfeedchain *ch, t_float v)
+{
+ t_rdfeeder *fe;
+ for (fe = ch->ch_head; fe; fe = fe->fe_next)
+ *fe->fe_picker->pi_data = v;
+}
+
+int riddle_isidle(t_riddle *rd)
+{
+ return (rd->rd_idlepicker && *rd->rd_idlepicker->pi_data > .5);
+}
+
+void riddle_updatedsp(void)
+{
+ t_rdenvironment *en = rdenvironment_provide();
+ loud_warning((t_pd *)en, 0, "...trying to reconstruct the dsp chain");
+ clock_delay(en->en_updatedspclock, 0);
+}
+
+
+/* rdremote: global named writers, global named readers,
+ and private anonymous bidirectional buffers */
+
+
+static t_rdremote *rdenvironment_getbuffer(t_rdenvironment *en, t_symbol *name)
+{
+ t_rdremote *re = en->en_writers;
+ while (re)
+ {
+ if (re->re_name == name)
+ return (re);
+ re = re->re_next;
+ }
+ return (0);
+}
+
+t_rdremote *rdremote_getwriter(t_rdremote *re)
+{
+ t_rdenvironment *en = rdenvironment_provide();
+ return (rdenvironment_getbuffer(en, re->re_name));
+}
+
+t_rdremote *rdremote_nextreader(t_rdremote *re)
+{
+ while (re && !re->re_id)
+ re = re->re_portlink;
+ return (re);
+}
+
+int rdremote_getsourceblock(t_rdremote *re)
+{
+ if (re->re_owner && re->re_id > 0)
+ return (riddle_getsourceblock(re->re_owner, -re->re_id));
+ else
+ {
+ loudbug_bug("rdremote_getsourceblock");
+ return (0);
+ }
+}
+
+t_symbol *rdremote_getsourcelayout(t_rdremote *re, int *maxblockp)
+{
+ if (re->re_owner && re->re_id > 0)
+ return (riddle_getsourcelayout(re->re_owner, -re->re_id, maxblockp));
+ else
+ {
+ loudbug_bug("rdremote_getsourcelayout");
+ return (0);
+ }
+}
+
+int rdremote_getsourceflags(t_rdremote *re)
+{
+ if (re->re_owner && re->re_id > 0)
+ return (riddle_getsourceflags(re->re_owner, -re->re_id));
+ else
+ {
+ loudbug_bug("rdremote_getsourceflags");
+ return (0);
+ }
+}
+
+/* this call reallocates memory if necessary, so the caller should check
+ for failures: the number of frames and/ot framesize may decrease
+ (the actually available framesize is returned by the call) */
+/* LATER optionally use old contents by zero-padding, interpolating, etc. */
+static int rdremote_setframesize(t_rdremote *re, int framesize)
+{
+ t_rdremote *reader;
+ if (re->re_inidata == 0)
+ {
+ /* not a writer */
+ loudbug_bug("rdremote_setframesize 1");
+ return (0);
+ }
+ if (framesize <= 0)
+ {
+ if (re->re_owner)
+ framesize = re->re_owner->rd_graphblock;
+ else
+ {
+ loudbug_bug("rdremote_setframesize 2");
+ return (0);
+ }
+ }
+ re->re_npoints = framesize * re->re_nframes;
+ if (re->re_npoints > re->re_datasize)
+ {
+ int reqsize = re->re_npoints;
+ /* LATER use grow_withdata() */
+ re->re_data = grow_nodata(&re->re_npoints, &re->re_datasize,
+ re->re_data, RDREMOTE_INISIZE,
+ re->re_inidata, sizeof(*re->re_data));
+ if (re->re_npoints != reqsize)
+ {
+ re->re_nframes = re->re_npoints / framesize;
+ if (re->re_nframes < 1)
+ {
+ loudbug_bug("rdremote_setframesize 3");
+ re->re_nframes = 1;
+ framesize = re->re_npoints;
+ }
+ }
+ }
+ /* LATER convert old buffer's contents of re->re_framesize * re->re_nframes
+ points into the new buffer of framesize * re->re_nframes points */
+ memset(re->re_data, 0, re->re_npoints * sizeof(*re->re_data));
+ re->re_phase = 0; /* LATER adjust */
+ re->re_maxphase = re->re_npoints - framesize;
+ re->re_framesize = framesize;
+
+ for (reader = re->re_readers; reader; reader = reader->re_next)
+ {
+ reader->re_nframes = re->re_nframes;
+ reader->re_framesize = re->re_framesize;
+ reader->re_npoints = re->re_npoints;
+ reader->re_maxphase = re->re_maxphase;
+ reader->re_data = re->re_data;
+ reader->re_phase = 0; /* LATER adjust */
+ }
+ return (framesize);
+}
+
+void rdremote_setoutblock(t_rdremote *re, int nblock)
+{
+ if (nblock = rdremote_setframesize(re, nblock))
+ {
+ t_rdremote *reader;
+ for (reader = re->re_readers; reader; reader = reader->re_next)
+ if (reader->re_owner && reader->re_id > 0)
+ riddle_setsourceblock(reader->re_owner, -reader->re_id,
+ re->re_framesize);
+ }
+}
+
+void rdremote_setoutlayout(t_rdremote *re, t_symbol *pattern, int maxblock)
+{
+ if (maxblock = rdremote_setframesize(re, maxblock))
+ {
+ t_rdremote *reader;
+ for (reader = re->re_readers; reader; reader = reader->re_next)
+ if (reader->re_owner && reader->re_id > 0)
+ riddle_setsourcelayout(reader->re_owner, -reader->re_id,
+ pattern, re->re_framesize);
+ }
+}
+
+void rdremote_setoutflags(t_rdremote *re, int flags)
+{
+ t_rdremote *reader;
+ for (reader = re->re_readers; reader; reader = reader->re_next)
+ if (reader->re_owner && reader->re_id > 0)
+ riddle_setsourceflags(reader->re_owner, -reader->re_id, flags);
+}
+
+void rdremote_reset(t_rdremote *re)
+{
+ if (re->re_inidata)
+ {
+ memset(re->re_data, 0, re->re_npoints * sizeof(*re->re_data));
+ re->re_phase = 0;
+ }
+ else
+ {
+ t_rdremote *writer = rdremote_getwriter(re);
+ if (writer)
+ re->re_phase = writer->re_phase;
+ else
+ re->re_phase = 0;
+ }
+}
+
+t_float *rdremote_gethead(t_rdremote *re)
+{
+ return (re->re_data + re->re_phase);
+}
+
+void rdremote_stephead(t_rdremote *re)
+{
+ re->re_phase += re->re_framesize;
+ if (re->re_phase > re->re_maxphase)
+ re->re_phase = 0;
+}
+
+void rdremote_movehead(t_rdremote *re, int nframes)
+{
+ if (re->re_nframes <= 0)
+ {
+ loudbug_bug("rdremote_movehead");
+ }
+ else if (nframes > 0)
+ {
+ if (nframes >= re->re_nframes)
+ nframes = re->re_nframes - 1;
+ re->re_phase += nframes * re->re_framesize;
+ while (re->re_phase > re->re_maxphase)
+ re->re_phase -= re->re_npoints;
+ }
+ else if (nframes < 0)
+ {
+ nframes = -nframes;
+ if (nframes >= re->re_nframes)
+ nframes = re->re_nframes - 1;
+ re->re_phase -= nframes * re->re_framesize;
+ while (re->re_phase < 0)
+ re->re_phase += re->re_npoints;
+ }
+}
+
+void rdremote_delayhead(t_rdremote *re, int nframes)
+{
+ if (re->re_inidata)
+ loudbug_bug("rdremote_delayhead"); /* not a reader */
+ else
+ {
+ t_rdremote *writer = rdremote_getwriter(re);
+ if (writer)
+ {
+ re->re_phase = writer->re_phase;
+ rdremote_movehead(re, -nframes);
+ }
+ }
+}
+
+static void rdremote_free(t_rdremote *re)
+{
+ if (re->re_inidata)
+ {
+ if (re->re_data != re->re_inidata)
+ freebytes(re->re_data, re->re_datasize * sizeof(*re->re_data));
+ if (re->re_name)
+ {
+ t_rdremote *reader;
+ t_rdenvironment *en = rdenvironment_provide();
+ /* remove from the environment */
+ if (re->re_next)
+ re->re_next->re_prev = re->re_prev;
+ if (re->re_prev)
+ re->re_prev->re_next = re->re_next;
+ else
+ en->en_writers = re->re_next;
+ /* move all readers to the orphanage */
+ if (reader = re->re_readers)
+ {
+ while (reader->re_next)
+ reader = reader->re_next;
+ if (en->en_readers)
+ en->en_readers->re_prev = reader;
+ reader->re_next = en->en_readers;
+ en->en_readers = re->re_readers;
+ }
+ }
+ }
+ else
+ {
+ if (re->re_name)
+ {
+ /* remove from writer's list or orphanage */
+ if (re->re_next)
+ re->re_next->re_prev = re->re_prev;
+ if (re->re_prev)
+ re->re_prev->re_next = re->re_next;
+ else
+ {
+ t_rdenvironment *en = rdenvironment_provide();
+ t_rdremote *writer = rdenvironment_getbuffer(en, re->re_name);
+ if (writer)
+ writer->re_readers = re->re_next;
+ else
+ en->en_readers = re->re_next;
+ }
+ }
+ }
+ freebytes(re, sizeof(*re));
+}
+
+void rdremote_freeports(t_rdremote *re)
+{
+ while (re)
+ {
+ t_rdremote *nxt = re->re_portlink;
+ rdremote_free(re);
+ re = nxt;
+ }
+}
+
+/* FIXME do not rely on pd_new() callocing owner->rd_nremoteslots
+ and owner->rd_remoteports to zero... one option is to traverse
+ environment in riddle_new() after newfn call */
+static t_rdremote *rdremote_newany(t_riddle *owner, t_symbol *name, int nframes)
+{
+ t_rdremote *re = (t_rdremote *)getbytes(sizeof(*re));
+ if (name && !nframes)
+ {
+ owner->rd_nremoteslots++;
+ re->re_id = owner->rd_nremoteslots; /* starting from 1 */
+ }
+ else re->re_id = 0;
+ re->re_name = 0;
+ re->re_owner = owner;
+ re->re_phase = 0;
+ re->re_nframes = nframes;
+ re->re_framesize = 0;
+ re->re_npoints = 0;
+ re->re_maxphase = 0;
+ if (nframes)
+ {
+ re->re_datasize = RDREMOTE_INISIZE;
+ re->re_inidata = getbytes(re->re_datasize * sizeof(*re->re_inidata));
+ re->re_data = re->re_inidata;
+ }
+ else
+ {
+ re->re_datasize = 0;
+ re->re_inidata = 0;
+ re->re_data = 0;
+ }
+ re->re_readers = 0;
+ re->re_prev = 0;
+ re->re_next = 0;
+ if (owner->rd_remoteports)
+ {
+ t_rdremote *prv = owner->rd_remoteports;
+ while (prv->re_portlink)
+ prv = prv->re_portlink;
+ prv->re_portlink = re;
+ }
+ else owner->rd_remoteports = re;
+ re->re_portlink = 0;
+ return (re);
+}
+
+t_rdremote *rdremote_newwriter(t_riddle *owner, t_symbol *name, int nframes)
+{
+ if (name && *name->s_name)
+ {
+ t_rdremote *re =
+ rdremote_newany(owner, name, (nframes > 1 ? nframes : 1));
+ t_rdenvironment *en = rdenvironment_provide();
+ if (rdenvironment_getbuffer(en, re->re_name))
+ {
+ /* LATER accumulating writers case */
+ loud_error((t_pd *)owner, "duplicate buffer name \"%s\"",
+ re->re_name->s_name);
+ /* FIXME put on the namesakes queue */
+ }
+ else
+ {
+ t_rdremote *reader;
+ /* store in the environment */
+ if (en->en_writers)
+ en->en_writers->re_prev = re;
+ re->re_next = en->en_writers;
+ en->en_writers = re;
+ /* recover readers from the orphanage */
+ for (reader = en->en_readers; reader; reader = reader->re_next)
+ {
+ if (reader->re_name == re->re_name)
+ {
+ if (reader->re_next)
+ reader->re_next->re_prev = reader->re_prev;
+ if (reader->re_prev)
+ reader->re_prev->re_next = reader->re_next;
+ else
+ en->en_readers = reader->re_next;
+ if (re->re_readers)
+ re->re_readers->re_prev = reader;
+ reader->re_next = re->re_readers;
+ re->re_readers = reader;
+ }
+ }
+ }
+ return (re);
+ }
+ else
+ {
+ loudbug_bug("rdremote_newwriter");
+ return (0);
+ }
+}
+
+t_rdremote *rdremote_newreader(t_riddle *owner, t_symbol *name)
+{
+ if (name && *name->s_name)
+ {
+ t_rdremote *re = rdremote_newany(owner, name, 0);
+ t_rdenvironment *en = rdenvironment_provide();
+ t_rdremote *writer = rdenvironment_getbuffer(en, name);
+ if (writer)
+ {
+ /* register to the writer */
+ if (writer->re_readers)
+ writer->re_readers->re_prev = re;
+ re->re_next = writer->re_readers;
+ writer->re_readers = re;
+ }
+ else
+ {
+ /* store in the orphanage */
+ if (en->en_readers)
+ en->en_readers->re_prev = re;
+ re->re_next = en->en_readers;
+ en->en_readers = re;
+ }
+ return (re);
+ }
+ else
+ {
+ loudbug_bug("rdremote_newreader");
+ return (0);
+ }
+}
+
+t_rdremote *rdremote_newbuffer(t_riddle *owner, int nframes)
+{
+ return (rdremote_newany(owner, 0, (nframes > 1 ? nframes : 1)));
+}
diff --git a/riddle/riddle.c b/riddle/riddle.c
index 26e17e7..1348413 100644
--- a/riddle/riddle.c
+++ b/riddle/riddle.c
@@ -11,97 +11,70 @@
#include "common/grow.h"
#include "sickle/sic.h"
#include "riddle.h"
+#include "riddleguts.h"
/* obj_starttraverseoutlet, obj_nexttraverseoutlet, obj_noutlets,
obj_nsiginlets, obj_nsigoutlets, obj_siginletindex, obj_sigoutletindex,
obj_issignalinlet, obj_issignaloutlet */
#include "m_imp.h"
-/* struct _glist, canvas_class */
+/* struct _glist, canvas_class, vinlet_class */
#include "g_canvas.h"
-#define RIDDLE_DEBUG
+/* it is horrible, but we need x_canvas and x_parentoutlet and o_next for
+ pushing through an outlet~, which is here for the completeness of the tests;
+ LATER remove from library version, unless there is an API way to do it... */
-typedef struct _rdenvironment
+/* from g_io.c */
+typedef struct _rdvoutlet
{
- t_pd re_pd;
- t_rdpool *re_graphpools;
- t_rdbuffer *re_writers;
- t_rdbuffer *re_readers; /* list of orphaned readers */
- t_clock *re_updatedspclock;
-} t_rdenvironment;
-
-static t_class *rdenvironment_class = 0;
-
-struct _rdsource
+ t_object x_obj;
+ t_canvas *x_canvas;
+ t_outlet *x_parentoutlet;
+ /* ... */
+} t_rdvoutlet;
+
+/* from m_obj.c */
+typedef struct _rdoutlet
{
- t_riddle *ri_riddle;
- int ri_sourcecount;
- t_symbol *ri_pattern;
- t_symbol *ri_newpattern;
- int ri_block; /* if non-zero pattern: largest expected block */
- int ri_newblock;
-};
+ t_object *o_owner;
+ struct _rdoutlet *o_next;
+ /* ... */
+} t_rdoutlet;
-struct _rdsink
+#define RIDDLE_DEBUG
+
+struct _rdprivate
{
- t_riddle *ro_riddle;
- int ro_outno;
- t_symbol *ro_pattern;
- int ro_block; /* if non-zero pattern: largest expected block */
- t_atom ro_outbuf[3]; /* siginno, pattern, block */
- int ro_isready;
- int ro_isstrict; /* if set: non-riddle sinks are rejected */
+ t_outconnect *pr_oc;
};
-#define RDPOOL_INISIZE 64
-
-typedef struct _rdlink
-{
- t_symbol *rl_key;
- int rl_size;
- int rl_maxsize;
- t_float *rl_data;
- t_float rl_inidata[RDPOOL_INISIZE];
- struct _rdlink *rl_next;
-} t_rdlink;
-
-struct _rdpool
+struct _rdsource
{
- t_canvas *rp_graph;
- int rp_refcount;
- t_rdlink *rp_links;
- t_rdpool *rp_prev;
- t_rdpool *rp_next;
+ t_riddle *so_riddle;
+ t_rdremote *so_remote;
+ int so_sourcecount;
+ t_symbol *so_pattern;
+ t_symbol *so_newpattern;
+ int so_block; /* if non-zero pattern: largest expected block */
+ int so_newblock;
+ int so_flags;
};
-#define RDBUFFER_INISIZE 1024
-
-struct _rdbuffer
+struct _rdsink
{
- t_symbol *rb_name;
- t_riddle *rb_owner;
- int rb_phase;
- t_rdbuffer *rb_prev;
- t_rdbuffer *rb_next;
-
- /* common part, copied from writer to all its readers
- immediately after any change */
- int rb_nframes;
- int rb_framesize;
- int rb_npoints;
- int rb_maxphase;
- t_float *rb_buf;
-
- /* writer-specific part */
- t_rdbuffer *rb_readers;
- int rb_bufsize;
- t_float *rb_bufini;
+ t_riddle *si_riddle;
+ int si_outno;
+ t_symbol *si_pattern;
+ int si_block; /* if non-zero pattern: largest expected block */
+ int si_flags;
+ t_atom si_outbuf[4]; /* siginno, pattern, block, flags */
+ t_rdfeedchain *si_feedchain;
+ int si_isready;
};
/* these are filled in riddle_setup() */
static t_symbol *rdps__reblock = 0;
-static t_symbol *rdps__idle = 0;
static t_symbol *rdps__ = 0;
void riddlebug_post(t_riddle *rd, char *pfx, char *fmt, ...)
@@ -123,221 +96,6 @@ void riddlebug_post(t_riddle *rd, char *pfx, char *fmt, ...)
#endif
}
-static void riddle_updatedsptick(t_rdenvironment *re)
-{
- canvas_update_dsp();
-}
-
-static void rdenvironment_anything(t_rdenvironment *re,
- t_symbol *s, int ac, t_atom *av)
-{
- /* FIXME */
-}
-
-static t_rdenvironment *rdenvironment_provide(void)
-{
- t_rdenvironment *re;
- t_symbol *ps__riddle = gensym("_riddle");
- t_symbol *ps_hashriddle = gensym("#riddle");
- if (ps_hashriddle->s_thing)
- {
- char *cname = class_getname(*ps_hashriddle->s_thing);
- if (strcmp(cname, ps__riddle->s_name))
- {
- /* FIXME protect against the danger of someone else
- (e.g. receive) binding to #riddle */
- loudbug_bug("rdenvironment_provide");
- }
- else
- {
- /* FIXME compatibility test */
- rdenvironment_class = *ps_hashriddle->s_thing;
- return ((t_rdenvironment *)ps_hashriddle->s_thing);
- }
- }
- rdenvironment_class = class_new(ps__riddle, 0, 0,
- sizeof(t_rdenvironment),
- CLASS_PD | CLASS_NOINLET, 0);
- class_addanything(rdenvironment_class, rdenvironment_anything);
- re = (t_rdenvironment *)pd_new(rdenvironment_class); /* never freed */
- re->re_graphpools = 0;
- re->re_writers = 0;
- re->re_readers = 0;
- re->re_updatedspclock = clock_new(re, (t_method)riddle_updatedsptick);
- pd_bind((t_pd *)re, ps_hashriddle); /* never unbound */
- return (re);
-}
-
-static t_rdpool *rdpool_attach(t_rdenvironment *re, t_canvas *graph)
-{
- t_rdpool *rp;
- for (rp = re->re_graphpools; rp; rp = rp->rp_next)
- if (rp->rp_graph == graph)
- break;
- if (rp)
- rp->rp_refcount++;
- else
- {
- rp = getbytes(sizeof(*rp));
- rp->rp_graph = graph;
- rp->rp_refcount = 1;
- rp->rp_links = 0;
- rp->rp_prev = 0;
- if (re->re_graphpools)
- re->re_graphpools->rp_prev = rp;
- rp->rp_next = re->re_graphpools;
- re->re_graphpools = rp;
- }
- return (rp);
-}
-
-static void rdpool_detach(t_rdpool *rp, t_rdenvironment *re)
-{
- if (rp->rp_refcount > 1)
- rp->rp_refcount--;
- else
- {
- while (rp->rp_links)
- {
- t_rdlink *rl = rp->rp_links;
- rp->rp_links = rl->rl_next;
- if (rl->rl_data)
- freebytes(rl->rl_data, rl->rl_size * sizeof(*rl->rl_data));
- freebytes(rl, sizeof(*rl));
- }
- if (rp->rp_prev)
- rp->rp_prev->rp_next = rp->rp_next;
- else
- re->re_graphpools = rp->rp_next;
- if (rp->rp_next)
- rp->rp_next->rp_prev = rp->rp_prev;
- freebytes(rp, sizeof(*rp));
- }
-}
-
-static void rdpool_setthis(t_rdpool *rp,
- t_symbol *key, int size, t_float *data)
-{
- t_rdlink *rl;
- for (rl = rp->rp_links; rl; rl = rl->rl_next)
- if (rl->rl_key == key)
- break;
- if (!rl)
- {
- rl = getbytes(sizeof(*rl));
- rl->rl_key = key;
- rl->rl_maxsize = RDPOOL_INISIZE;
- rl->rl_data = rl->rl_inidata;
- rl->rl_next = rp->rp_links;
- rp->rp_links = rl;
- }
- if (size > rl->rl_maxsize)
- rl->rl_data = grow_nodata(&size, &rl->rl_maxsize, rl->rl_data,
- RDPOOL_INISIZE, rl->rl_inidata,
- sizeof(*rl->rl_data));
- rl->rl_size = size;
- memcpy(rl->rl_data, data, size * sizeof(*rl->rl_data));
-}
-
-static void rdpool_proliferate(t_rdpool *rphead, t_gobj *g,
- t_symbol *key, int size, t_float *data)
-{
- for (; g; g = g->g_next)
- {
- if (pd_class((t_pd *)g) == canvas_class)
- {
- t_canvas *graph = (t_canvas *)g;
- t_rdpool *rp;
- for (rp = rphead; rp; rp = rp->rp_next)
- if (rp->rp_graph == graph)
- break;
- if (rp)
- rdpool_setthis(rp, key, size, data);
- rdpool_proliferate(rphead, graph->gl_list, key, size, data);
- }
- }
-}
-
-/* LATER setcache */
-void rdpool_set(t_rdpool *rp, t_symbol *key, int size, t_float *data)
-{
- t_rdenvironment *re = rdenvironment_provide();
- rdpool_setthis(rp, key, size, data);
- rdpool_proliferate(re->re_graphpools, (t_gobj *)rp->rp_graph,
- key, size, data);
-}
-
-/* LATER setcache */
-void rdpool_setbygraph(t_canvas *graph, t_symbol *key, int size, t_float *data)
-{
- t_rdenvironment *re = rdenvironment_provide();
- t_rdpool *rp;
- for (rp = re->re_graphpools; rp; rp = rp->rp_next)
- if (rp->rp_graph == graph)
- break;
- if (rp)
- rdpool_setthis(rp, key, size, data);
- rdpool_proliferate(re->re_graphpools, (t_gobj *)graph, key, size, data);
-}
-
-t_float *rdpool_get(t_rdpool *rp, t_symbol *key, int *sizep)
-{
- t_rdlink *rl;
- for (rl = rp->rp_links; rl; rl = rl->rl_next)
- {
- if (rl->rl_key == key)
- {
- *sizep = rl->rl_size;
- return (rl->rl_data);
- }
- }
- return (0);
-}
-
-t_float *riddle_getlink(t_riddle *rd, t_symbol *key, int *sizep)
-{
- return (rdpool_get(rd->rd_graphpool, key, sizep));
-}
-
-/* LATER traversal api */
-t_canvas *riddle_getgraph(t_riddle *rd, int sigoutno)
-{
- t_outlet *op;
- int outno = rd->rd_outslots[sigoutno].ro_outno;
- t_outconnect *oc = obj_starttraverseoutlet((t_object *)rd, &op, outno);
- while (oc)
- {
- t_object *dst;
- t_inlet *ip;
- int inno;
- oc = obj_nexttraverseoutlet(oc, &dst, &ip, &inno);
- if (dst)
- {
- int siginno = obj_siginletindex(dst, inno);
- if (siginno < 0)
- {
- /* should not happen, LATER rethink */
- break;
- }
- else if (pd_class((t_pd *)dst) != canvas_class)
- {
- loud_error((t_pd *)rd, "invalid connection (not to a canvas)");
- break;
- }
- else return ((t_canvas *)dst);
- }
- }
- return (0);
-}
-
-
-void riddle_updatedsp(void)
-{
- t_rdenvironment *re = rdenvironment_provide();
- loud_warning((t_pd *)re, 0, "...trying to reconstruct the dsp chain");
- clock_delay(re->re_updatedspclock, 0);
-}
-
int riddle_getsr(t_riddle *rd)
{
return (rd->rd_graphsr);
@@ -357,58 +115,49 @@ int riddle_getsourceblock(t_riddle *rd, int siginno)
}
else
{
- t_rdsource *slot = (siginno >= 0 ?
- rd->rd_inslots + siginno :
- rd->rd_remoteslots - ++siginno);
- return (slot->ri_pattern ? 0 : slot->ri_block);
+ t_rdsource *so = (siginno >= 0 ?
+ rd->rd_inslots + siginno :
+ rd->rd_remoteslots - ++siginno);
+ return (so->so_pattern ? 0 : so->so_block); /* FIXME disable? */
}
}
-t_symbol *riddle_getsourcepattern(t_riddle *rd, int siginno, int *maxblockp)
+t_symbol *riddle_getsourcelayout(t_riddle *rd, int siginno, int *maxblockp)
{
if (siginno >= rd->rd_nsiginlets || -siginno > rd->rd_nremoteslots)
{
- loudbug_bug("riddle_getsourcepattern");
+ loudbug_bug("riddle_getsourcelayout");
return (0);
}
else
{
- t_rdsource *slot = (siginno >= 0 ?
- rd->rd_inslots + siginno :
- rd->rd_remoteslots - ++siginno);
+ t_rdsource *so = (siginno >= 0 ?
+ rd->rd_inslots + siginno :
+ rd->rd_remoteslots - ++siginno);
if (maxblockp)
- *maxblockp = slot->ri_block;
- return (slot->ri_pattern);
+ *maxblockp = so->so_block;
+ return (so->so_pattern);
}
}
-int riddle_getoutblock(t_riddle *rd, int sigoutno)
+int riddle_getsourceflags(t_riddle *rd, int siginno)
{
- if (sigoutno >= rd->rd_nsigoutlets || sigoutno < 0)
- {
- loudbug_bug("riddle_getoutblock");
- return (0);
- }
- else return (rd->rd_outslots[sigoutno].ro_pattern ?
- 0 : rd->rd_outslots[sigoutno].ro_block);
-}
-
-t_symbol *riddle_getoutpattern(t_riddle *rd, int sigoutno, int *maxblockp)
-{
- if (sigoutno >= rd->rd_nsigoutlets || sigoutno < 0)
+ if (siginno >= rd->rd_nsiginlets || -siginno > rd->rd_nremoteslots)
{
- loudbug_bug("riddle_getoutpattern");
+ loudbug_bug("riddle_getsourceflags");
return (0);
}
else
{
- if (maxblockp)
- *maxblockp = rd->rd_outslots[sigoutno].ro_block;
- return (rd->rd_outslots[sigoutno].ro_pattern);
+ t_rdsource *so = (siginno >= 0 ?
+ rd->rd_inslots + siginno :
+ rd->rd_remoteslots - ++siginno);
+ return (so->so_flags);
}
}
-static void riddle_setsourceblock(t_riddle *rd, int siginno, int newblock)
+/* LATER rethink the remote case */
+void riddle_setsourceblock(t_riddle *rd, int siginno, int newblock)
{
int slotno = (siginno < 0 ? rd->rd_nsiginlets - siginno - 1 : siginno);
#ifdef RIDDLE_DEBUG
@@ -422,128 +171,186 @@ static void riddle_setsourceblock(t_riddle *rd, int siginno, int newblock)
"invalid source block on inlet %d: %d", siginno, newblock);
else
{
- t_rdsource *slot = rd->rd_inslots + slotno;
- /* LATER if (slot->ri_newpattern) complain */
- if (newblock == slot->ri_newblock)
- slot->ri_sourcecount++;
- else if (slot->ri_sourcecount > 0)
+ t_rdsource *so = rd->rd_inslots + slotno;
+ /* LATER if (so->so_newpattern) complain */
+ if (newblock == so->so_newblock)
+ so->so_sourcecount++;
+ else if (so->so_sourcecount > 0)
loud_error((t_pd *)rd,
"source block mismatch on inlet %d: %d != %d",
- siginno, newblock, slot->ri_newblock);
+ siginno, newblock, so->so_newblock);
else
{
- slot->ri_newblock = newblock;
- slot->ri_sourcecount = 1;
- if (siginno < 0)
- rd->rd_remotesource = 1;
+ so->so_newblock = newblock;
+ so->so_sourcecount = 1;
}
}
}
-/* LATER pattern validation and normalization (e.g. xXXX -> aAAA */
-static void riddle_setsourcepattern(t_riddle *rd, int siginno,
- t_symbol *newpattern, int maxblock)
+#define RDLAYOUT_MAXNVECTORS 32
+
+/* apart from normalization, this is used only as a sanity check; patterns
+ are never interpreted, they just have to match (after normalization) */
+static t_symbol *riddle_validatepattern(t_symbol *pattern)
+{
+ char *p = pattern->s_name, lc, uc;
+ switch (*p)
+ {
+ case 'a':
+ case 'A':
+ lc = 'b'; uc = 'A'; break;
+ case 'b':
+ lc = 'c'; uc = 'B'; break;
+ default:
+ lc = 0;
+ }
+ if (lc)
+ {
+ /* we require at least one vector for each size element */
+ int vused[RDLAYOUT_MAXNVECTORS], i;
+ for (i = 0; i < RDLAYOUT_MAXNVECTORS; i++)
+ vused[i] = 0;
+ if (*p == 'A')
+ vused[0] = 1;
+ for (p++; *p; p++)
+ {
+ if (*p == lc)
+ {
+ if (lc - 'a' < RDLAYOUT_MAXNVECTORS)
+ lc++, uc++;
+ else
+ break;
+ }
+ else if (*p >= 'A' && *p <= uc)
+ vused[*p - 'A'] = 1;
+ else
+ break;
+ }
+ if (!*p)
+ {
+ for (i = 0; i < lc - 'a'; i++)
+ if (!vused[i])
+ break;
+ if (i == lc - 'a')
+ {
+ if (*pattern->s_name == 'a') /* normalization */
+ pattern = gensym(pattern->s_name + 1);
+ return (pattern);
+ }
+ }
+ }
+ loudbug_bug("riddle_validatepattern");
+ return (0);
+}
+
+void riddle_setsourcelayout(t_riddle *rd, int siginno,
+ t_symbol *newpattern, int maxblock)
{
int slotno = (siginno < 0 ? rd->rd_nsiginlets - siginno - 1 : siginno);
#ifdef RIDDLE_DEBUG
- riddlebug_post(rd, "setsourcepattern", "%d (%d) %s %d",
+ riddlebug_post(rd, "setsourcelayout", "%d (%d) %s %d",
siginno, slotno, newpattern->s_name, maxblock);
#endif
if (siginno >= rd->rd_nsiginlets || -siginno > rd->rd_nremoteslots)
- loudbug_bug("riddle_setsourcepattern");
+ loudbug_bug("riddle_setsourcelayout");
else
{
- t_rdsource *slot = rd->rd_inslots + slotno;
- if (newpattern == slot->ri_newpattern)
- slot->ri_sourcecount++;
- else if (slot->ri_sourcecount > 0)
+ t_rdsource *so = rd->rd_inslots + slotno;
+ if (newpattern == so->so_newpattern)
+ so->so_sourcecount++;
+ else if (so->so_sourcecount > 0)
{
- if (slot->ri_newpattern)
+ if (so->so_newpattern)
loud_error((t_pd *)rd,
- "source pattern mismatch on inlet %d: %s != %s",
+ "source layout mismatch on inlet %d: %s != %s",
siginno, newpattern->s_name,
- slot->ri_newpattern->s_name);
+ so->so_newpattern->s_name);
else
loud_error((t_pd *)rd,
- "source pattern/block mismatch on inlet %d");
+ "source layout/block mismatch on inlet %d");
}
- else
+ else if (newpattern = riddle_validatepattern(newpattern))
{
- slot->ri_newpattern = newpattern;
+ so->so_newpattern = newpattern;
if (maxblock)
{
- if (maxblock > slot->ri_newblock)
- slot->ri_newblock = maxblock;
+ if (maxblock > so->so_newblock)
+ so->so_newblock = maxblock;
}
- else slot->ri_newblock = rd->rd_graphblock;
- slot->ri_sourcecount = 1;
- if (siginno < 0)
- rd->rd_remotesource = 1;
+ else so->so_newblock = rd->rd_graphblock;
+ so->so_sourcecount = 1;
}
}
}
+void riddle_setsourceflags(t_riddle *rd, int siginno, int flags)
+{
+ int slotno = (siginno < 0 ? rd->rd_nsiginlets - siginno - 1 : siginno);
+#ifdef RIDDLE_DEBUG
+ riddlebug_post(rd, "setsourceflags", "%d (%d) %d",
+ siginno, slotno, flags);
+#endif
+ if (siginno >= rd->rd_nsiginlets || -siginno > rd->rd_nremoteslots)
+ loudbug_bug("riddle_setsourceflags");
+ else
+ {
+ t_rdsource *so = rd->rd_inslots + slotno;
+ so->so_flags = flags;
+ }
+}
+
void riddle_setoutblock(t_riddle *rd, int sigoutno, int block)
{
- t_rdsink *slot;
#ifdef RIDDLE_DEBUG
riddlebug_post(rd, "setoutblock", "%d %d", sigoutno, block);
#endif
- if (sigoutno >= rd->rd_nsigoutlets)
+ if (sigoutno < 0 || sigoutno >= rd->rd_nsigoutlets)
loudbug_bug("riddle_setoutblock");
- else if (sigoutno < 0)
- {
- for (sigoutno = 0, slot = rd->rd_outslots;
- sigoutno < rd->rd_nsigoutlets; sigoutno++, slot++)
- {
- slot->ro_pattern = 0;
- slot->ro_block = block;
- slot->ro_outbuf[1].a_w.w_symbol = rdps__;
- slot->ro_outbuf[2].a_w.w_float = (t_float)block;
- slot->ro_isready = 1;
- }
- }
else
{
- slot = rd->rd_outslots + sigoutno;
- slot->ro_pattern = 0;
- slot->ro_block = block;
- slot->ro_outbuf[1].a_w.w_symbol = rdps__;
- slot->ro_outbuf[2].a_w.w_float = (t_float)block;
- slot->ro_isready = 1;
+ t_rdsink *si = rd->rd_outslots + sigoutno;
+ si->si_pattern = 0;
+ si->si_block = block;
+ si->si_outbuf[1].a_w.w_symbol = rdps__;
+ si->si_outbuf[2].a_w.w_float = (t_float)block;
+ si->si_isready = 1;
}
}
-void riddle_setoutpattern(t_riddle *rd, int sigoutno,
- t_symbol *pattern, int maxblock)
+void riddle_setoutlayout(t_riddle *rd, int sigoutno,
+ t_symbol *pattern, int maxblock)
{
- t_rdsink *slot;
#ifdef RIDDLE_DEBUG
- riddlebug_post(rd, "setoutpattern", "%d %s %d",
+ riddlebug_post(rd, "setoutlayout", "%d %s %d",
sigoutno, pattern->s_name, maxblock);
#endif
- if (sigoutno >= rd->rd_nsigoutlets)
- loudbug_bug("riddle_setoutpattern");
- else if (sigoutno < 0)
+ if (sigoutno < 0 || sigoutno >= rd->rd_nsigoutlets)
+ loudbug_bug("riddle_setoutlayout");
+ else if (pattern = riddle_validatepattern(pattern))
{
- for (sigoutno = 0, slot = rd->rd_outslots;
- sigoutno < rd->rd_nsigoutlets; sigoutno++, slot++)
- {
- slot->ro_pattern = pattern;
- slot->ro_block = maxblock;
- slot->ro_outbuf[1].a_w.w_symbol = pattern;
- slot->ro_outbuf[2].a_w.w_float = (t_float)maxblock;
- slot->ro_isready = 1;
- }
+ t_rdsink *si = rd->rd_outslots + sigoutno;
+ if (maxblock <= 0)
+ maxblock = rd->rd_graphblock;
+ si->si_pattern = pattern;
+ si->si_block = maxblock;
+ si->si_outbuf[1].a_w.w_symbol = pattern;
+ si->si_outbuf[2].a_w.w_float = (t_float)maxblock;
+ si->si_isready = 1;
}
+}
+
+void riddle_setoutflags(t_riddle *rd, int sigoutno, int flags)
+{
+#ifdef RIDDLE_DEBUG
+ riddlebug_post(rd, "setoutflags", "%d %d", sigoutno, flags);
+#endif
+ if (sigoutno < 0 || sigoutno >= rd->rd_nsigoutlets)
+ loudbug_bug("riddle_setoutflags");
else
{
- slot = rd->rd_outslots;
- slot->ro_pattern = pattern;
- slot->ro_block = maxblock;
- slot->ro_outbuf[1].a_w.w_symbol = pattern;
- slot->ro_outbuf[2].a_w.w_float = (t_float)maxblock;
- slot->ro_isready = 1;
+ t_rdsink *si = rd->rd_outslots + sigoutno;
+ si->si_flags = flags;
+ si->si_outbuf[3].a_w.w_float = (t_float)flags;
}
}
@@ -554,7 +361,7 @@ int riddle_checksourceblock(t_riddle *rd, int siginno, int reqblock)
return (1);
else
{
- if (!rd->rd_wasdisabled && rd->rd_inslots[siginno].ri_sourcecount)
+ if (!rd->rd_wasdisabled && rd->rd_inslots[siginno].so_sourcecount)
loud_error((t_pd *)rd,
"invalid source block on inlet %d: %d (%d expected)",
siginno, block, reqblock);
@@ -563,24 +370,24 @@ int riddle_checksourceblock(t_riddle *rd, int siginno, int reqblock)
}
}
-/* LATER pattern normalization (e.g. xXXX -> aAAA */
-int riddle_checksourcepattern(t_riddle *rd, int siginno,
- t_symbol *reqpattern, int *maxblockp)
+int riddle_checksourcelayout(t_riddle *rd, int siginno,
+ t_symbol *reqpattern, int *maxblockp)
{
- t_symbol *pattern = riddle_getsourcepattern(rd, siginno, maxblockp);
- if (pattern == reqpattern)
+ t_symbol *pattern = riddle_getsourcelayout(rd, siginno, maxblockp);
+ if (reqpattern == pattern ||
+ riddle_validatepattern(reqpattern) == pattern)
return (1);
else
{
- if (!rd->rd_wasdisabled && rd->rd_inslots[siginno].ri_sourcecount)
+ if (!rd->rd_wasdisabled && rd->rd_inslots[siginno].so_sourcecount)
{
if (pattern)
loud_error((t_pd *)rd,
- "wrong source pattern on inlet %d: %s (%s expected)",
+ "wrong source layout on inlet %d: %s (%s expected)",
siginno, pattern->s_name, reqpattern->s_name);
else
loud_error((t_pd *)rd,
- "invalid source on inlet %d: pattern %s expected",
+ "invalid source on inlet %d: layout %s expected",
siginno, reqpattern->s_name);
}
rd->rd_disabled = 1;
@@ -594,10 +401,10 @@ int riddle_checkanysource(t_riddle *rd, int siginno)
loudbug_bug("riddle_checkanysource");
else
{
- t_rdsource *slot = (siginno >= 0 ?
- rd->rd_inslots + siginno :
- rd->rd_remoteslots - ++siginno);
- if (slot->ri_sourcecount > 0)
+ t_rdsource *so = (siginno >= 0 ?
+ rd->rd_inslots + siginno :
+ rd->rd_remoteslots - ++siginno);
+ if (so->so_sourcecount > 0)
return (1);
}
rd->rd_disabled = 1;
@@ -611,9 +418,35 @@ int riddle_isdisabled(t_riddle *rd)
void riddle_disable(t_riddle *rd)
{
+ /* FIXME allow calling from the dsp routine (mute then) */
rd->rd_disabled = 1;
}
+t_rdfeedchain *riddle_getfeedchain(t_riddle *rd, int sigoutno)
+{
+ if (sigoutno < 0 || sigoutno >= rd->rd_nsigoutlets)
+ {
+ loudbug_bug("riddle_getfeedchain 1");
+ return (0);
+ }
+ else
+ {
+ t_rdsink *si = rd->rd_outslots + sigoutno;
+ if (si->si_outno >= 0)
+ {
+ /* LATER update ch_outno */
+ return (si->si_feedchain);
+ }
+ else
+ {
+ loudbug_bug("riddle_getfeedchain 2");
+ return (0);
+ }
+ }
+}
+
+/* ensures that sinks match signal outlets -- this is needed in the constructor,
+ but is called before each push, perhaps too defensively... LATER rethink */
static int riddle_validatesinks(t_riddle *rd)
{
t_object *x = (t_object *)rd;
@@ -624,10 +457,10 @@ static int riddle_validatesinks(t_riddle *rd)
{
if (sigoutno < rd->rd_nsigoutlets)
{
- if (rd->rd_outslots[sigoutno].ro_outno != outno)
+ if (rd->rd_outslots[sigoutno].si_outno != outno)
{
- if (rd->rd_outslots[sigoutno].ro_outno < 0)
- rd->rd_outslots[sigoutno].ro_outno = outno;
+ if (rd->rd_outslots[sigoutno].si_outno < 0)
+ rd->rd_outslots[sigoutno].si_outno = outno;
else
{
loudbug_bug("riddle_validatesinks 1");
@@ -653,12 +486,46 @@ static int riddle_validatesinks(t_riddle *rd)
return (1);
}
-static int rdsink_push(t_rdsink *slot)
+t_canvas *riddle_nextgraph(t_riddle *rd)
+{
+ while (rd->rd_private->pr_oc)
+ {
+ t_object *dst;
+ t_inlet *ip;
+ int inno;
+ rd->rd_private->pr_oc =
+ obj_nexttraverseoutlet(rd->rd_private->pr_oc, &dst, &ip, &inno);
+ if (dst)
+ {
+ int siginno = obj_siginletindex(dst, inno);
+ if (siginno < 0)
+ {
+ /* should not happen, LATER rethink */
+ break;
+ }
+ else if (pd_class((t_pd *)dst) != canvas_class)
+ {
+ loud_error((t_pd *)rd, "invalid connection (not to a canvas)");
+ break;
+ }
+ else return ((t_canvas *)dst);
+ }
+ }
+ return (0);
+}
+
+t_canvas *riddle_firstgraph(t_riddle *rd, int outno)
+{
+ t_outlet *op;
+ rd->rd_private->pr_oc = obj_starttraverseoutlet((t_object *)rd, &op, outno);
+ return (rd->rd_private->pr_oc ? riddle_nextgraph(rd) : 0);
+}
+
+static int rdsink_push(t_rdsink *si, t_object *x, int outno)
{
int result = 1;
- t_object *x = (t_object *)slot->ro_riddle;
t_outlet *op;
- t_outconnect *oc = obj_starttraverseoutlet(x, &op, slot->ro_outno);
+ t_outconnect *oc = obj_starttraverseoutlet(x, &op, outno);
while (oc)
{
t_object *dst;
@@ -672,18 +539,83 @@ static int rdsink_push(t_rdsink *slot)
{
/* should not happen, LATER rethink */
}
- /* LATER unify isriddle test as zgetfn(..., gensym("dspblock")) */
else if (zgetfn((t_pd *)dst, rdps__reblock))
{
- slot->ro_outbuf->a_w.w_float = (t_float)siginno;
- typedmess((t_pd *)dst, rdps__reblock, 3, slot->ro_outbuf);
+ si->si_outbuf->a_w.w_float = (t_float)siginno;
+ typedmess((t_pd *)dst, rdps__reblock, 4, si->si_outbuf);
}
- else if (slot->ro_isstrict)
+ else if (pd_class((t_pd *)dst) == canvas_class)
+ {
+ t_gobj *ob;
+ int i;
+ for (i = 0, ob = ((t_canvas *)dst)->gl_list;
+ ob; ob = ob->g_next)
+ {
+ if (pd_class((t_pd *)ob) == vinlet_class)
+ {
+ if (i == inno)
+ break;
+ else
+ i++;
+ }
+ }
+ if (ob)
+ {
+#ifdef RIDDLE_DEBUG
+ riddlebug_post(si->si_riddle, "PUSH-SUBCANVAS",
+ "vinlet %d (\"%s\")",
+ inno, class_getname(*(t_pd *)ob));
+#endif
+ rdsink_push(si, (t_object *)ob, 0);
+ }
+ else loudbug_bug("rdsink_push 1");
+ }
+ else if (pd_class((t_pd *)dst) == voutlet_class)
+ {
+ t_rdvoutlet *vout = (t_rdvoutlet *)dst;
+ if (vout->x_canvas)
+ {
+ int n;
+ t_outlet *o;
+ for (o = ((t_object *)vout->x_canvas)->ob_outlet, n = 0;
+ o; o = (t_outlet *)(((t_rdoutlet *)o)->o_next), n++)
+ if (o == vout->x_parentoutlet)
+ break;
+ if (o)
+ {
+#ifdef RIDDLE_DEBUG
+ riddlebug_post(si->si_riddle, "PUSH-OUTLET",
+ "outno %d, graph %x",
+ n, (int)vout->x_canvas);
+#endif
+ rdsink_push(si, (t_object *)vout->x_canvas, n);
+ }
+ else loudbug_bug("rdsink_push 2");
+ }
+#ifdef RIDDLE_DEBUG
+ else riddlebug_post(si->si_riddle, "PUSH-OUTLET",
+ "void canvas...");
+#endif
+ }
+ else
{
char *dstname = class_getname(*(t_pd *)dst);
- if (strcmp(dstname, "print~"))
+#ifdef RIDDLE_DEBUG
+ riddlebug_post(si->si_riddle, "PUSH-RIDDLESS",
+ "inlet %d (\"%s\")", inno, dstname);
+#endif
+ if (si->si_flags & RIDDLE_STRICTNESSMASK)
{
- loud_error((t_pd *)x, "not a riddle: \"%s\"", dstname);
+ if (strcmp(dstname, "print~"))
+ {
+ loud_error((t_pd *)x, "not a riddle: \"%s\"", dstname);
+ result = 0;
+ }
+ }
+ else if (!strcmp(dstname, "send~") ||
+ !strcmp(dstname, "throw~"))
+ {
+ loud_error((t_pd *)x, "bad destination: \"%s\"", dstname);
result = 0;
}
}
@@ -692,10 +624,10 @@ static int rdsink_push(t_rdsink *slot)
return (result);
}
-void riddle_mute(t_riddle *rd, t_signal **sp)
+static void riddle_mute(t_riddle *rd, t_signal **sp)
{
int i, j, nouts = obj_nsigoutlets((t_object *)rd);
- t_rdsink *slot = rd->rd_outslots;
+ t_rdsink *si = rd->rd_outslots;
#ifdef RIDDLE_DEBUG
riddlebug_post(rd, "MUTE", 0);
#endif
@@ -710,14 +642,14 @@ void riddle_mute(t_riddle *rd, t_signal **sp)
j = obj_nsiginlets((t_object *)rd);
while (nouts--)
{
- slot->ro_pattern = 0;
- slot->ro_block = sp[j]->s_n;
- slot->ro_outbuf[1].a_w.w_symbol = rdps__;
- slot->ro_outbuf[2].a_w.w_float = (t_float)slot->ro_block;
- slot->ro_isready = 1;
+ si->si_pattern = 0;
+ si->si_block = sp[j]->s_n;
+ si->si_outbuf[1].a_w.w_symbol = rdps__;
+ si->si_outbuf[2].a_w.w_float = (t_float)si->si_block;
+ si->si_isready = 1;
dsp_add_zero(sp[j]->s_vec, sp[j]->s_n);
i++; j++;
- slot++;
+ si++;
}
}
@@ -736,13 +668,14 @@ static void riddle_dsp(t_riddle *rd, t_signal **sp)
for (inslotno = 0, inslot = rd->rd_inslots;
inslotno < ninslots; inslotno++, inslot++)
loudbug_post("%d sources: %d reblocks of %d -> %d",
- inslotno, inslot->ri_sourcecount,
- inslot->ri_block, inslot->ri_newblock);
+ inslotno, inslot->so_sourcecount,
+ inslot->so_block, inslot->so_newblock);
#endif
rd->rd_graphsr = (int)sp[0]->s_sr;
rd->rd_graphblock = sp[0]->s_n;
+ /* this belongs to step 2., but should precede all "muteandreset" gotos */
if (rd->rd_wasdisabled = rd->rd_disabled)
{
rd->rd_disabled = 0;
@@ -750,53 +683,71 @@ static void riddle_dsp(t_riddle *rd, t_signal **sp)
doreblock = 1;
else
{
- loudbug_bug("riddle_dsp 2");
+ loudbug_bug("riddle_dsp 1");
goto muteandreset;
}
}
- /* verify all source slots */
+ /* step 1: verify all source slots */
+
for (inslotno = 0, inslot = rd->rd_inslots;
inslotno < ninslots; inslotno++, inslot++)
{
- if (inslot->ri_newblock > rd->rd_graphblock)
+ if (inslot->so_newblock > rd->rd_graphblock)
{
- loud_error((t_pd *)rd,
- "inslot %d: source block too large (%d > %d)",
- inslotno, inslot->ri_newblock, rd->rd_graphblock);
- failed = 1;
+ if (inslotno < rd->rd_nsiginlets)
+ {
+ loud_error((t_pd *)rd,
+ "inslot %d: source block too large (%d > %d)",
+ inslotno, inslot->so_newblock, rd->rd_graphblock);
+ failed = 1;
+ }
}
- else if (inslot->ri_sourcecount <= 0)
+ else if (inslot->so_sourcecount <= 0)
{
- if (rd->rd_remotesource) /* this is an `issticky' flag -- it tells
- if unconfirmed sourceblock should be
- preserved or bashed to graphblock */
+ if (inslotno < rd->rd_nsiginlets)
{
- inslot->ri_newpattern = inslot->ri_pattern;
- if (inslot->ri_block > 0)
- inslot->ri_newblock = inslot->ri_block;
- else
- inslot->ri_newblock = rd->rd_graphblock;
+ /* bash unconfirmed declarations to graphblock */
+ inslot->so_newpattern = 0;
+ inslot->so_newblock = rd->rd_graphblock;
}
- else
+ else if (inslot->so_remote)
{
- inslot->ri_newpattern = 0;
- inslot->ri_newblock = rd->rd_graphblock;
+ if (rdremote_getwriter(inslot->so_remote))
+ {
+ loud_warning((t_pd *)rd, 0, "misplaced buffer reader...");
+ riddle_updatedsp();
+ failed = 1; /* LATER rethink */
+ }
+ else
+ {
+ loud_warning((t_pd *)rd, 0, "orphaned buffer reader");
+
+ /* remote slots preserve unconfirmed declarations */
+ inslot->so_newpattern = inslot->so_pattern;
+ if (inslot->so_block > 0)
+ inslot->so_newblock = inslot->so_block;
+ else
+ inslot->so_newblock = rd->rd_graphblock;
+ }
}
+ else loudbug_bug("riddle_dsp 2");
}
- else if (inslot->ri_newblock <= 0) /* should not happen */
+ else if (inslot->so_newblock <= 0) /* should not happen */
{
- loudbug_bug("riddle_dsp 1");
+ loudbug_bug("riddle_dsp 3");
failed = 1;
}
}
if (failed)
goto muteandreset;
- /* determine outblock sizes -- blockfn fires on the very first call
- to riddle_dsp(), and then after any change of block or sr,
- and each time the object is disabled...
- LATER reconsider reblocking during every dsp call... */
+ /* step 2: determine outslot sizes/layouts -- blockfn fires on the very
+ first call to riddle_dsp(), and then after any change of block or sr,
+ and each time the object is disabled... LATER reconsider the pros
+ and cons of performing the reblocking during every dsp call */
+
+ /* 2a: was there any change of inslot size/layout or graph block/sr? */
if (!doreblock && rd->rd_blockfn)
{
if (rd->rd_graphsr != oldgraphsr ||
@@ -805,8 +756,8 @@ static void riddle_dsp(t_riddle *rd, t_signal **sp)
else for (inslotno = 0, inslot = rd->rd_inslots;
inslotno < ninslots; inslotno++, inslot++)
{
- if (inslot->ri_newpattern != inslot->ri_pattern ||
- inslot->ri_newblock != inslot->ri_block)
+ if (inslot->so_newpattern != inslot->so_pattern ||
+ inslot->so_newblock != inslot->so_block)
{
doreblock = 1;
break;
@@ -814,23 +765,25 @@ static void riddle_dsp(t_riddle *rd, t_signal **sp)
}
}
+ /* 2b: update the inslots, reset the outslots */
if (doreblock || !rd->rd_blockfn)
{
- for (outslotno = 0, outslot = rd->rd_outslots;
- outslotno < rd->rd_nsigoutlets; outslotno++, outslot++)
- {
- outslot->ro_pattern = 0;
- outslot->ro_block = 0;
- outslot->ro_isready = 0;
- }
for (inslotno = 0, inslot = rd->rd_inslots;
inslotno < ninslots; inslotno++, inslot++)
{
- inslot->ri_pattern = inslot->ri_newpattern;
- inslot->ri_block = inslot->ri_newblock;
+ inslot->so_pattern = inslot->so_newpattern;
+ inslot->so_block = inslot->so_newblock;
+ }
+ for (outslotno = 0, outslot = rd->rd_outslots;
+ outslotno < rd->rd_nsigoutlets; outslotno++, outslot++)
+ {
+ outslot->si_pattern = 0;
+ outslot->si_block = 0;
+ outslot->si_isready = 0;
}
}
+ /* 2c: call the instance-specific method which redeclares the outslots */
if (doreblock)
{
#ifdef RIDDLE_DEBUG
@@ -841,20 +794,24 @@ static void riddle_dsp(t_riddle *rd, t_signal **sp)
goto muteandreset;
}
+ /* 2d: assign defaults to undeclared outslots */
for (outslotno = 0, outslot = rd->rd_outslots;
outslotno < rd->rd_nsigoutlets; outslotno++, outslot++)
{
- if (outslot->ro_block < 0)
+ if (outslot->si_block < 0)
{
- loudbug_bug("riddle_dsp 3");
+ loudbug_bug("riddle_dsp 4");
failed = 1;
}
- else if (outslot->ro_block == 0)
- outslot->ro_block = rd->rd_graphblock;
+ else if (outslot->si_block == 0)
+ outslot->si_block = rd->rd_graphblock;
}
+ /* LATER think about not redeclared remote writers */
if (failed)
goto muteandreset;
+ /* step 3: transfer outslot declarations down to destination objects */
+
#ifdef RIDDLE_DEBUG
riddlebug_post(rd, "PUSH", 0);
#endif
@@ -862,19 +819,27 @@ static void riddle_dsp(t_riddle *rd, t_signal **sp)
{
for (outslotno = 0, outslot = rd->rd_outslots;
outslotno < rd->rd_nsigoutlets; outslotno++, outslot++)
- if (outslot->ro_isready && rdsink_push(outslot) == 0)
+ if (outslot->si_isready &&
+ rdsink_push(outslot, (t_object *)rd, outslot->si_outno) == 0)
failed = 1;
}
else failed = 1;
+ /* remote declarations are propagated directly from within
+ rdremote_setoutblock/layout(), cf. rdremote_pushblock/layout() */
if (failed)
goto muteandreset;
+
+ /* step 4: call the wrappee */
+
if (rd->rd_dspfn)
{
rd->rd_dspfn(rd, sp);
unarmed = 0;
}
- else loudbug_bug("riddle_dsp 4");
+ else loudbug_bug("riddle_dsp 5");
+
+ /* step 5: mute if disabled, then reset the inslots */
muteandreset:
if (unarmed)
@@ -885,40 +850,54 @@ muteandreset:
for (inslotno = 0, inslot = rd->rd_inslots;
inslotno < ninslots; inslotno++, inslot++)
{
- inslot->ri_newpattern = 0;
- inslot->ri_newblock = 0;
- inslot->ri_sourcecount = 0;
+ inslot->so_newpattern = 0;
+ inslot->so_newblock = 0;
+ inslot->so_sourcecount = 0;
}
- rd->rd_remotesource = 0;
}
-static void riddle__reblock(t_riddle *rd,
- t_symbol *pattern, t_floatarg f1, t_floatarg f2)
+static void riddle__reblock(t_riddle *rd, t_symbol *pattern,
+ t_floatarg f1, t_floatarg f2, t_floatarg f3)
{
+ riddle_setsourceflags(rd, (int)f1, (int)f3);
if (pattern == rdps__)
riddle_setsourceblock(rd, (int)f1, (int)f2);
- /* LATER replace with full validation done in riddle_setsourcepattern() */
- else if (pattern && *pattern->s_name == 'a')
- riddle_setsourcepattern(rd, (int)f1, pattern, (int)f2);
+ else if (pattern)
+ riddle_setsourcelayout(rd, (int)f1, pattern, (int)f2);
else
loud_error((t_pd *)rd, "bad arguments to '_reblock'");
}
static void riddle_free(t_riddle *rd)
{
- int nslots;
t_gotfn freefn = zgetfn((t_pd *)rd, gensym("_free"));
if (freefn)
freefn(rd);
- rdpool_detach(rd->rd_graphpool, rdenvironment_provide());
+ if (rd->rd_private)
+ freebytes(rd->rd_private, sizeof(*rd->rd_private));
- nslots = rd->rd_nsiginlets + rd->rd_nremoteslots;
if (rd->rd_inslots)
+ {
+ int nslots = rd->rd_nsiginlets + rd->rd_nremoteslots;
freebytes(rd->rd_inslots, nslots * sizeof(*rd->rd_inslots));
+ }
+
if (rd->rd_outslots)
+ {
+ t_rdsink *si;
+ int i;
+ for (i = 0, si = rd->rd_outslots; i < rd->rd_nsigoutlets; i++, si++)
+ if (si->si_feedchain)
+ rdfeedchain_free(si->si_feedchain);
freebytes(rd->rd_outslots,
rd->rd_nsigoutlets * sizeof(*rd->rd_outslots));
+ }
+
+ rdremote_freeports(rd->rd_remoteports);
+
+ if (rd->rd_idlepicker)
+ rdpicker_detach(rd->rd_idlepicker, rd);
}
typedef t_pd *(*t_newgimme)(t_symbol *s, int argc, t_atom *argv);
@@ -926,8 +905,8 @@ typedef t_pd *(*t_newgimme)(t_symbol *s, int argc, t_atom *argv);
static void *riddle_new(t_symbol *s, int ac, t_atom *av)
{
/* IFBUILTIN remove: this is a bad hack */
- t_rdenvironment *re = rdenvironment_provide();
- t_newgimme newfn = (t_newgimme)zgetfn((t_pd *)re, s);
+ t_pd *en = riddle_getenvironment();
+ t_newgimme newfn = (t_newgimme)zgetfn(en, s);
if (!newfn)
{
loudbug_bug("riddle_new 1");
@@ -939,8 +918,12 @@ static void *riddle_new(t_symbol *s, int ac, t_atom *av)
int i, nslots;
t_rdsource *inslot;
t_rdsink *outslot;
+ t_rdremote *re;
if (!rd)
return (0);
+
+ rd->rd_private = getbytes(sizeof(*rd->rd_private));
+
rd->rd_disabled = 0;
rd->rd_wasdisabled = 0;
rd->rd_blockfn = (t_rdblockfn)zgetfn((t_pd *)rd, gensym("dspblock"));
@@ -948,53 +931,77 @@ static void *riddle_new(t_symbol *s, int ac, t_atom *av)
if (!rd->rd_dspfn)
loudbug_bug("riddle_new 2");
- rd->rd_graphpool = rdpool_attach(re, canvas_getcurrent());
-
rd->rd_graphsr = (int)sys_getsr();
rd->rd_graphblock = sys_getblksize();
rd->rd_nsiginlets = obj_nsiginlets((t_object *)rd);
rd->rd_nsigoutlets = obj_nsigoutlets((t_object *)rd);
- nslots = rd->rd_nsiginlets + rd->rd_nremoteslots;
+ /* currently, rd_nremoteslots is incremented in rdbuffer_newreader(),
+ which relies on calloc in pd_new(), LATER rethink */
+
+ nslots = rd->rd_nsiginlets + rd->rd_nremoteslots;
rd->rd_inslots = getbytes(nslots * sizeof(*rd->rd_inslots));
for (i = 0, inslot = rd->rd_inslots; i < nslots; i++, inslot++)
{
- inslot->ri_riddle = rd;
- inslot->ri_sourcecount = 0;
- inslot->ri_pattern = 0;
- inslot->ri_newpattern = 0;
- inslot->ri_block = 0;
- inslot->ri_newblock = 0;
+ inslot->so_riddle = rd;
+ inslot->so_remote = 0;
+ inslot->so_sourcecount = 0;
+ inslot->so_pattern = 0;
+ inslot->so_newpattern = 0;
+ inslot->so_block = 0;
+ inslot->so_newblock = 0;
+ inslot->so_flags = 0;
}
rd->rd_remoteslots = rd->rd_inslots + rd->rd_nsiginlets;
+ for (i = 0, inslot = rd->rd_remoteslots, re = rd->rd_remoteports;
+ i < rd->rd_nremoteslots; i++, inslot++)
+ {
+ if (re = rdremote_nextreader(re))
+ inslot->so_remote = re;
+ else
+ {
+ loudbug_bug("riddle_new 3");
+ break; /* FIXME this is fatal */
+ }
+ }
+
rd->rd_outslots =
getbytes(rd->rd_nsigoutlets * sizeof(*rd->rd_outslots));
for (i = 0, outslot = rd->rd_outslots;
i < rd->rd_nsigoutlets; i++, outslot++)
{
- outslot->ro_riddle = rd;
- outslot->ro_outno = -1;
- outslot->ro_pattern = 0;
- outslot->ro_block = 0;
- outslot->ro_outbuf[0].a_type = A_FLOAT;
- outslot->ro_outbuf[1].a_type = A_SYMBOL;
- outslot->ro_outbuf[1].a_w.w_symbol = rdps__;
- outslot->ro_outbuf[2].a_type = A_FLOAT;
- outslot->ro_isready = 0;
- outslot->ro_isstrict = 0; /* LATER rethink */
+ outslot->si_riddle = rd;
+ outslot->si_outno = -1;
+ outslot->si_pattern = 0;
+ outslot->si_block = 0;
+ outslot->si_flags = 0;
+ outslot->si_outbuf[0].a_type = A_FLOAT;
+ outslot->si_outbuf[1].a_type = A_SYMBOL;
+ outslot->si_outbuf[1].a_w.w_symbol = rdps__;
+ outslot->si_outbuf[2].a_type = A_FLOAT;
+ outslot->si_outbuf[3].a_type = A_FLOAT;
+ outslot->si_outbuf[3].a_w.w_float = 0.;
+ outslot->si_feedchain = 0;
+ outslot->si_isready = 0;
}
+
riddle_validatesinks(rd);
- /* currently, rd->rd_nremoteslots is incremented in
- rdbuffer_newreader(), LATER rethink */
+ for (i = 0, outslot = rd->rd_outslots;
+ i < rd->rd_nsigoutlets; i++, outslot++)
+ if (outslot->si_outno >= 0)
+ outslot->si_feedchain = rdfeedchain_new(outslot->si_outno);
+
+ rd->rd_idlepicker = rdpicker_attach(rd, gensym("_idle"));
- rd->rd_remotesource = 0;
return (rd);
}
}
/* IFBUILTIN remove: classes would use explicit class_addmethod calls */
+/* obligatory: newfn, dspfn */
+/* optional: freefn, blockfn, floatfn */
t_class *riddle_setup(t_symbol *name, t_newmethod newfn, t_method freefn,
size_t sz, t_method floatfn,
t_rdblockfn blockfn, t_rddspfn dspfn)
@@ -1003,327 +1010,43 @@ t_class *riddle_setup(t_symbol *name, t_newmethod newfn, t_method freefn,
(t_method)riddle_free, sz, 0, A_GIMME, 0);
/* IFBUILTIN remove: this is a bad hack */
- t_rdenvironment *re = rdenvironment_provide();
- class_addmethod(*(t_pd *)re, (t_method)newfn, name, 0);
+ t_pd *en = riddle_getenvironment();
+ class_addmethod(*en, (t_method)newfn, name, 0);
if (strlen(name->s_name) < 60)
{
char rdstr[64];
sprintf(rdstr, "rd.%s", name->s_name);
class_addcreator((t_newmethod)riddle_new, gensym(rdstr), A_GIMME, 0);
- class_addmethod(*(t_pd *)re, (t_method)newfn, gensym(rdstr), 0);
+ class_addmethod(*en, (t_method)newfn, gensym(rdstr), 0);
}
rdps__reblock = gensym("_reblock");
- rdps__idle = gensym("_idle");
rdps__ = gensym("_");
sic_setup(c, riddle_dsp, floatfn);
- class_addmethod(c, (t_method)blockfn, gensym("dspblock"), 0);
+ if (blockfn)
+ class_addmethod(c, (t_method)blockfn, gensym("dspblock"), 0);
/* IFBUILTIN "_dsp" -> "dsp" */
class_addmethod(c, (t_method)dspfn, gensym("_dsp"), 0);
/* IFBUILTIN remove these two */
class_addmethod(c, (t_method)newfn, gensym("_new"), 0);
- class_addmethod(c, (t_method)freefn, gensym("_free"), 0);
+ if (freefn)
+ class_addmethod(c, (t_method)freefn, gensym("_free"), 0);
class_addmethod(c, (t_method)riddle__reblock,
- rdps__reblock, A_FLOAT, A_SYMBOL, A_FLOAT, 0);
+ rdps__reblock, A_FLOAT, A_SYMBOL, A_FLOAT, A_FLOAT, 0);
return (c);
}
-static t_rdbuffer *rdenvironment_getbuffer(t_rdenvironment *re, t_symbol *name)
-{
- t_rdbuffer *rb = re->re_writers;
- while (rb)
- {
- if (rb->rb_name == name)
- return (rb);
- rb = rb->rb_next;
- }
- return (0);
-}
-
-t_rdbuffer *riddle_getbuffer(t_symbol *name)
-{
- t_rdenvironment *re = rdenvironment_provide();
- return (rdenvironment_getbuffer(re, name));
-}
-
-t_rdbuffer *rdbuffer_getwriter(t_rdbuffer *rb)
-{
- t_rdenvironment *re = rdenvironment_provide();
- return (rdenvironment_getbuffer(re, rb->rb_name));
-}
-
-static void rdbuffer_updatereaders(t_rdbuffer *rb)
-{
- t_rdbuffer *reader;
- for (reader = rb->rb_readers; reader; reader = reader->rb_next)
- {
- reader->rb_nframes = rb->rb_nframes;
- reader->rb_framesize = rb->rb_framesize;
- reader->rb_npoints = rb->rb_npoints;
- reader->rb_maxphase = rb->rb_maxphase;
- reader->rb_buf = rb->rb_buf;
- reader->rb_phase = 0; /* LATER adjust */
- if (reader->rb_owner)
- /* FIXME -1 - reader->rb_slotno */
- riddle_setsourceblock(reader->rb_owner, -1, rb->rb_framesize);
- }
-}
-
-/* FIXME return the actually allocated size */
-/* LATER optionally use old contents by zero-padding, interpolating, etc. */
-void rdbuffer_validate(t_rdbuffer *rb, int nblock)
-{
- if (rb->rb_bufini == 0)
- {
- loudbug_bug("rdbuffer_validate 1");
- return;
- }
- rb->rb_npoints = nblock * rb->rb_nframes;
- if (rb->rb_npoints > rb->rb_bufsize)
- {
- int reqsize = rb->rb_npoints;
- /* LATER use grow_withdata() */
- rb->rb_buf = grow_nodata(&rb->rb_npoints, &rb->rb_bufsize, rb->rb_buf,
- RDBUFFER_INISIZE, rb->rb_bufini,
- sizeof(*rb->rb_buf));
- if (rb->rb_npoints != reqsize)
- {
- rb->rb_nframes = rb->rb_npoints / nblock;
- if (rb->rb_nframes < 1)
- {
- loudbug_bug("rdbuffer_validate 2");
- rb->rb_nframes = 1;
- nblock = rb->rb_npoints;
- }
- }
- }
- /* LATER convert old buffer's contents of rb->rb_framesize * rb->rb_nframes
- points into the new buffer of nblock * rb->rb_nframes points */
- memset(rb->rb_buf, 0, rb->rb_npoints * sizeof(*rb->rb_buf));
- rb->rb_phase = 0; /* LATER adjust */
- rb->rb_maxphase = rb->rb_npoints - nblock;
- rb->rb_framesize = nblock;
- rdbuffer_updatereaders(rb);
-}
-
-void rdbuffer_reset(t_rdbuffer *rb)
-{
- if (rb->rb_bufini)
- memset(rb->rb_buf, 0, rb->rb_npoints * sizeof(*rb->rb_buf));
- rb->rb_phase = 0;
-}
-
-int rdbuffer_getframesize(t_rdbuffer *rb)
-{
- return (rb->rb_framesize);
-}
-
-t_float *rdbuffer_gethead(t_rdbuffer *rb)
-{
- return (rb->rb_buf + rb->rb_phase);
-}
-
-void rdbuffer_stephead(t_rdbuffer *rb)
-{
- rb->rb_phase += rb->rb_framesize;
- if (rb->rb_phase > rb->rb_maxphase)
- rb->rb_phase = 0;
-}
-
-void rdbuffer_movehead(t_rdbuffer *rb, int nframes)
-{
- if (rb->rb_nframes <= 0)
- {
- loudbug_bug("rdbuffer_movehead");
- }
- else if (nframes > 0)
- {
- if (nframes >= rb->rb_nframes)
- nframes = rb->rb_nframes - 1;
- rb->rb_phase += nframes * rb->rb_framesize;
- while (rb->rb_phase > rb->rb_maxphase)
- rb->rb_phase -= rb->rb_npoints;
- }
- else if (nframes < 0)
- {
- nframes = -nframes;
- if (nframes >= rb->rb_nframes)
- nframes = rb->rb_nframes - 1;
- rb->rb_phase -= nframes * rb->rb_framesize;
- while (rb->rb_phase < 0)
- rb->rb_phase += rb->rb_npoints;
- }
-}
-
-void rdbuffer_delayhead(t_rdbuffer *rb, int nframes)
-{
- if (rb->rb_bufini)
- loudbug_bug("rdbuffer_delayhead 1");
- else
- {
- t_rdbuffer *writer = riddle_getbuffer(rb->rb_name);
- if (writer)
- {
- rb->rb_phase = writer->rb_phase;
- rdbuffer_movehead(rb, -nframes);
- }
- else loudbug_bug("rdbuffer_delayhead 2");
- }
-}
-
-void rdbuffer_free(t_rdbuffer *rb)
-{
- if (rb->rb_bufini)
- {
- if (rb->rb_buf != rb->rb_bufini)
- freebytes(rb->rb_buf, rb->rb_bufsize * sizeof(*rb->rb_buf));
- if (rb->rb_name)
- {
- t_rdbuffer *reader;
- t_rdenvironment *re = rdenvironment_provide();
- /* remove from the environment */
- if (rb->rb_next)
- rb->rb_next->rb_prev = rb->rb_prev;
- if (rb->rb_prev)
- rb->rb_prev->rb_next = rb->rb_next;
- else
- re->re_writers = rb->rb_next;
- /* move all readers to the orphanage */
- if (reader = rb->rb_readers)
- {
- while (reader->rb_next)
- reader = reader->rb_next;
- if (re->re_readers)
- re->re_readers->rb_prev = reader;
- reader->rb_next = re->re_readers;
- re->re_readers = rb->rb_readers;
- }
- }
- }
- else
- {
- if (rb->rb_name)
- {
- /* remove from writer's list or orphanage */
- if (rb->rb_next)
- rb->rb_next->rb_prev = rb->rb_prev;
- if (rb->rb_prev)
- rb->rb_prev->rb_next = rb->rb_next;
- else
- {
- t_rdenvironment *re = rdenvironment_provide();
- t_rdbuffer *writer = rdenvironment_getbuffer(re, rb->rb_name);
- if (writer)
- writer->rb_readers = rb->rb_next;
- else
- re->re_readers = rb->rb_next;
- }
- }
- }
- freebytes(rb, sizeof(*rb));
-}
-
-t_rdbuffer *rdbuffer_new(t_riddle *owner, t_symbol *name, int nframes)
-{
- t_rdbuffer *rb = (t_rdbuffer *)getbytes(sizeof(*rb));
- rb->rb_name = (name && *name->s_name ? name : 0);
- rb->rb_owner = owner;
- rb->rb_phase = 0;
- rb->rb_nframes = (nframes > 1 ? nframes : 1);
- rb->rb_framesize = 0;
- rb->rb_npoints = 0;
- rb->rb_maxphase = 0;
- rb->rb_bufsize = RDBUFFER_INISIZE;
- rb->rb_bufini = getbytes(rb->rb_bufsize * sizeof(*rb->rb_bufini));
- rb->rb_buf = rb->rb_bufini;
- rb->rb_readers = 0;
- rb->rb_prev = 0;
- rb->rb_next = 0;
- if (rb->rb_name)
- {
- t_rdenvironment *re = rdenvironment_provide();
- if (rdenvironment_getbuffer(re, rb->rb_name))
- {
- loud_error((t_pd *)owner, "duplicate buffer name \"%s\"",
- rb->rb_name->s_name);
- }
- else
- {
- t_rdbuffer *reader;
- /* store in the environment */
- if (re->re_writers)
- re->re_writers->rb_prev = rb;
- rb->rb_next = re->re_writers;
- re->re_writers = rb;
- /* recover readers from the orphanage */
- for (reader = re->re_readers; reader; reader = reader->rb_next)
- {
- if (reader->rb_name == rb->rb_name)
- {
- if (reader->rb_next)
- reader->rb_next->rb_prev = reader->rb_prev;
- if (reader->rb_prev)
- reader->rb_prev->rb_next = reader->rb_next;
- else
- re->re_readers = reader->rb_next;
- if (rb->rb_readers)
- rb->rb_readers->rb_prev = reader;
- reader->rb_next = rb->rb_readers;
- rb->rb_readers = reader;
- }
- }
- }
- }
- return (rb);
-}
-
-t_rdbuffer *rdbuffer_newreader(t_riddle *owner, t_symbol *name)
-{
- t_rdbuffer *rb = (t_rdbuffer *)getbytes(sizeof(*rb));
- /* FIXME do not rely on pd_new() callocing owner->rd_nremoteslots to zero */
- owner->rd_nremoteslots++;
- rb->rb_name = (name && *name->s_name ? name : 0);
- rb->rb_owner = owner;
- rb->rb_phase = 0;
- rb->rb_nframes = 0;
- rb->rb_framesize = 0;
- rb->rb_npoints = 0;
- rb->rb_maxphase = 0;
- rb->rb_buf = 0;
- rb->rb_bufini = 0;
- rb->rb_prev = 0;
- rb->rb_next = 0;
- if (rb->rb_name)
- {
- t_rdenvironment *re = rdenvironment_provide();
- t_rdbuffer *writer = rdenvironment_getbuffer(re, rb->rb_name);
- if (writer)
- {
- /* register to the writer */
- if (writer->rb_readers)
- writer->rb_readers->rb_prev = rb;
- rb->rb_next = writer->rb_readers;
- writer->rb_readers = rb;
- }
- else
- {
- /* store in the orphanage */
- if (re->re_readers)
- re->re_readers->rb_prev = rb;
- rb->rb_next = re->re_readers;
- re->re_readers = rb;
- }
- }
- return (rb);
-}
-
-int riddle_erbfill(int nbands, int *buf, int nblock, int sr)
+/* Fills an array of band sizes, in bins, which partition an nbins-point power
+ spectrum into nbands or less ERB bands (nbands is a requested number of
+ bands, the actual number is returned). The buffer is then zero-terminated
+ (and zero-padded if necessary), so its size has to be at least nbands+1. */
+int riddle_erbfill(int nbands, int *buf, int nbins, int sr)
{
static double coef = 9.293902; /* 21.4 / log(10) */
- double df = (double)sr / (double)nblock;
- double fmax = .5 * (nblock + 1) * df;
+ double df = (double)sr / (double)nbins;
+ double fmax = .5 * (nbins + 1) * df;
double fc = df;
int i, erbcount = 0, bincount = 0, lastbin = 0;
int bufsize = nbands + 1;
diff --git a/riddle/riddle.h b/riddle/riddle.h
index 12d5907..0795f5f 100644
--- a/riddle/riddle.h
+++ b/riddle/riddle.h
@@ -2,103 +2,132 @@
* For information on usage and redistribution, and for a DISCLAIMER OF ALL
* WARRANTIES, see the file, "LICENSE.txt," in this distribution. */
+/* these are the riddle external API declarations */
+
#ifndef __RIDDLE_H__
#define __RIDDLE_H__
EXTERN_STRUCT _riddle;
#define t_riddle struct _riddle
+EXTERN_STRUCT _rdprivate;
+#define t_rdprivate struct _rdprivate
+
EXTERN_STRUCT _rdsource;
#define t_rdsource struct _rdsource
EXTERN_STRUCT _rdsink;
#define t_rdsink struct _rdsink
-EXTERN_STRUCT _rdpool;
-#define t_rdpool struct _rdpool
+EXTERN_STRUCT _rdpicker;
+#define t_rdpicker struct _rdpicker
+
+EXTERN_STRUCT _rdfeedchain;
+#define t_rdfeedchain struct _rdfeedchain
-EXTERN_STRUCT _rdbuffer;
-#define t_rdbuffer struct _rdbuffer
+EXTERN_STRUCT _rdremote;
+#define t_rdremote struct _rdremote
typedef void (*t_rdblockfn)(t_riddle *);
typedef void (*t_rddspfn)(t_riddle *, t_signal **);
struct _riddle
{
- t_sic rd_sic;
+ t_sic rd_sic;
+
+ /* LATER rethink: indirection cost vs. abi stability */
+ t_rdprivate *rd_private;
/* designed for system-level control: block mismatches, etc.
- (user-level control via '_idle' slot in graphpool) */
- int rd_disabled;
- int rd_wasdisabled;
+ (user-level control possible via the '_idle' slot in graphpool) */
+ int rd_disabled;
+ int rd_wasdisabled;
t_rdblockfn rd_blockfn;
t_rddspfn rd_dspfn;
- t_rdpool *rd_graphpool;
-
- int rd_graphsr;
- int rd_graphblock;
+ int rd_graphsr;
+ int rd_graphblock;
int rd_nsiginlets;
int rd_nremoteslots;
- t_rdsource *rd_inslots; /* rd_nsiginlets + rd_nremoteslots elements */
- t_rdsource *rd_remoteslots; /* == rd_inslots + rd_nsiginlets */
+ t_rdsource *rd_inslots; /* nsiginlets + nremoteslots elements */
+ t_rdsource *rd_remoteslots; /* == inslots + nsiginlets (readers only) */
+ t_rdremote *rd_remoteports; /* the list of all remotes */
- int rd_nsigoutlets;
- t_rdsink *rd_outslots; /* rd_nsigoutlets elements */
+ int rd_nsigoutlets;
+ t_rdsink *rd_outslots; /* nsigoutlets elements */
- int rd_remotesource; /* LATER consider storing remote sources here */
+ t_rdpicker *rd_idlepicker;
};
-void riddlebug_post(t_riddle *rd, char *pfx, char *fmt, ...);
+#define RIDDLE_STRICTNESSMASK 1 /* if set: non-riddle sinks are rejected */
-int riddle_getsr(t_riddle *rd);
-int riddle_getgraphblock(t_riddle *rd);
+/* the main part of the API */
int riddle_getsourceblock(t_riddle *rd, int siginno);
-t_symbol *riddle_getsourcepattern(t_riddle *rd, int siginno, int *maxblockp);
-int riddle_getoutblock(t_riddle *rd, int sigoutno);
-t_symbol *riddle_getoutpattern(t_riddle *rd, int sigoutno, int *maxblockp);
+t_symbol *riddle_getsourcelayout(t_riddle *rd, int siginno, int *maxblockp);
+int riddle_getsourceflags(t_riddle *rd, int siginno);
+/* or perhaps, IFBUILTIN, int inlet_getblock(t_inlet *)... */
void riddle_setoutblock(t_riddle *rd, int sigoutno, int newblock);
-void riddle_setoutpattern(t_riddle *rd, int sigoutno,
- t_symbol *pattern, int maxblock);
+void riddle_setoutlayout(t_riddle *rd, int sigoutno,
+ t_symbol *pattern, int maxblock);
+void riddle_setoutflags(t_riddle *rd, int sigoutno, int flags);
+/* or perhaps, IFBUILTIN, void outlet_setblock(t_outlet *, int)... */
int riddle_checksourceblock(t_riddle *rd, int siginno, int reqblock);
-int riddle_checksourcepattern(t_riddle *rd, int siginno,
- t_symbol *reqpattern, int *maxblockp);
-int riddle_checkanysource(t_riddle *rd, int siginno);
+int riddle_checksourcelayout(t_riddle *rd, int siginno,
+ t_symbol *reqpattern, int *maxblockp);
int riddle_isdisabled(t_riddle *rd);
void riddle_disable(t_riddle *rd);
-void riddle_mute(t_riddle *rd, t_signal **sp);
+
+/* this part is specific to the library implementation */
t_class *riddle_setup(t_symbol *name, t_newmethod newfn, t_method freefn,
size_t sz, t_method floatfn,
t_rdblockfn blockfn, t_rddspfn dspfn);
-void riddle_updatedsp(void);
-
-void rdpool_set(t_rdpool *rp, t_symbol *key, int size, t_float *data);
-void rdpool_setbygraph(t_canvas *graph, t_symbol *key, int size, t_float *data);
-t_float *rdpool_get(t_rdpool *rp, t_symbol *key, int *sizep);
-t_float *riddle_getlink(t_riddle *rd, t_symbol *key, int *sizep);
-t_canvas *riddle_getgraph(t_riddle *rd, int sigoutno);
-
-t_rdbuffer *riddle_getbuffer(t_symbol *name);
-t_rdbuffer *rdbuffer_getwriter(t_rdbuffer *rb);
-void rdbuffer_validate(t_rdbuffer *rb, int nblock);
-void rdbuffer_reset(t_rdbuffer *rb);
-int rdbuffer_getframesize(t_rdbuffer *rb);
-t_float *rdbuffer_gethead(t_rdbuffer *rb);
-void rdbuffer_stephead(t_rdbuffer *rb);
-void rdbuffer_movehead(t_rdbuffer *rb, int nframes);
-void rdbuffer_delayhead(t_rdbuffer *rb, int nframes);
-void rdbuffer_free(t_rdbuffer *rb);
-t_rdbuffer *rdbuffer_new(t_riddle *owner, t_symbol *name, int nframes);
-t_rdbuffer *rdbuffer_newreader(t_riddle *owner, t_symbol *name);
-
-int riddle_erbfill(int nbands, int *buf, int nblock, int sr);
+/* this part is very experimental: remote connections */
+
+t_rdremote *rdremote_newwriter(t_riddle *owner, t_symbol *name, int nframes);
+t_rdremote *rdremote_newreader(t_riddle *owner, t_symbol *name);
+t_rdremote *rdremote_newbuffer(t_riddle *owner, int nframes);
+
+int rdremote_getsourceblock(t_rdremote *re);
+t_symbol *rdremote_getsourcelayout(t_rdremote *re, int *maxblockp);
+int rdremote_getsourceflags(t_rdremote *re);
+
+void rdremote_setoutblock(t_rdremote *re, int nblock);
+void rdremote_setoutlayout(t_rdremote *re, t_symbol *pattern, int maxblock);
+void rdremote_setoutflags(t_rdremote *re, int flags);
+
+void rdremote_reset(t_rdremote *re);
+t_float *rdremote_gethead(t_rdremote *re);
+void rdremote_stephead(t_rdremote *re);
+void rdremote_movehead(t_rdremote *re, int nframes);
+void rdremote_delayhead(t_rdremote *re, int nframes);
+
+t_rdpicker *rdpicker_attach(t_riddle *rd, t_symbol *key);
+void rdpicker_detach(t_rdpicker *pi, t_riddle *rd);
+t_float *rdpicker_pick(t_rdpicker *pi, int *sizep);
+t_float rdpicker_pick1(t_rdpicker *pi);
+int riddle_isidle(t_riddle *rd);
+
+t_rdfeedchain *riddle_usefeedchain(t_riddle *rd,
+ int sigoutno, t_symbol *key, int size);
+t_rdfeedchain *riddle_useidlechain(t_riddle *rd, int sigoutno);
+void rdfeedchain_feed(t_rdfeedchain *ch, int size, t_float *data);
+void rdfeedchain_feed1(t_rdfeedchain *ch, t_float v);
+
+/* utilities */
+
+void riddlebug_post(t_riddle *rd, char *pfx, char *fmt, ...);
+
+int riddle_getsr(t_riddle *rd);
+int riddle_getgraphblock(t_riddle *rd);
+
+int riddle_erbfill(int nbands, int *buf, int nbins, int sr);
#endif
diff --git a/riddle/riddleguts.h b/riddle/riddleguts.h
new file mode 100644
index 0000000..b6354e2
--- /dev/null
+++ b/riddle/riddleguts.h
@@ -0,0 +1,35 @@
+/* Copyright (c) 2007 krzYszcz and others.
+ * For information on usage and redistribution, and for a DISCLAIMER OF ALL
+ * WARRANTIES, see the file, "LICENSE.txt," in this distribution. */
+
+/* these declarations do not belong to the riddle API
+ and should not be used by riddle externals */
+
+#ifndef __RIDDLEGUTS_H__
+#define __RIDDLEGUTS_H__
+
+/* from riddle.c */
+
+void riddle_setsourceblock(t_riddle *rd, int siginno, int newblock);
+void riddle_setsourcelayout(t_riddle *rd, int siginno,
+ t_symbol *newpattern, int maxblock);
+void riddle_setsourceflags(t_riddle *rd, int siginno, int flags);
+
+t_canvas *riddle_nextgraph(t_riddle *rd);
+t_canvas *riddle_firstgraph(t_riddle *rd, int outno);
+
+t_rdfeedchain *riddle_getfeedchain(t_riddle *rd, int sigoutno);
+
+/* from rdremote.c */
+
+t_pd *riddle_getenvironment(void);
+void riddle_updatedsp(void);
+
+void rdfeedchain_free(t_rdfeedchain *ch);
+t_rdfeedchain *rdfeedchain_new(int outno);
+
+t_rdremote *rdremote_getwriter(t_rdremote *re);
+t_rdremote *rdremote_nextreader(t_rdremote *re);
+void rdremote_freeports(t_rdremote *re);
+
+#endif