Update of /cvsroot/pure-data/externals/maxlib/src
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv15190
Modified Files:
netserver.c
Log Message:
added syslog-style debug message levels
Index: netserver.c
===================================================================
RCS file: /cvsroot/pure-data/externals/maxlib/src/netserver.c,v
retrieving revision 1.10
retrieving revision 1.11
diff -C2 -d -r1.10 -r1.11
*** netserver.c 20 Mar 2004 05:56:30 -0000 1.10
--- netserver.c 20 Mar 2004 22:45:16 -0000 1.11
***************
*** 57,62 ****
#define INBUFSIZE 4096 /* size of receiving data buffer */
! static char *version = "netserver v0.2 :: bidirectional communication for Pd\n"
! " written by Olaf Matthes <olaf.matthes(a)gmx.de>";
/* ----------------------------- netserver ------------------------- */
--- 57,74 ----
#define INBUFSIZE 4096 /* size of receiving data buffer */
! /* message levels from syslog.h */
[...1099 lines suppressed...]
! class_addmethod(netserver_class, (t_method)netserver_info, gensym("info"), 0);
! class_addmethod(netserver_class, (t_method)netserver_info, gensym("verbose"), 0);
! class_addmethod(netserver_class, (t_method)netserver_debug, gensym("debug"), 0);
!
! class_sethelpsymbol(netserver_class, gensym("help-netserver.pd"));
! post(version);
}
#else
void maxlib_netserver_setup(void)
{
! netserver_class = class_new(gensym("maxlib_netserver"),(t_newmethod)netserver_new, (t_method)netserver_free,
! sizeof(t_netserver), 0, A_DEFFLOAT, 0);
! class_addcreator((t_newmethod)netserver_new, gensym("netserver"), A_DEFFLOAT, 0);
! class_addmethod(netserver_class, (t_method)netserver_print, gensym("print"), 0);
! class_addmethod(netserver_class, (t_method)netserver_send, gensym("send"), A_GIMME, 0);
! class_addmethod(netserver_class, (t_method)netserver_client_send, gensym("client"), A_GIMME, 0);
! class_addmethod(netserver_class, (t_method)netserver_broadcast, gensym("broadcast"), A_GIMME, 0);
! class_sethelpsymbol(netserver_class, gensym("maxlib/help-netserver.pd"));
}
#endif
1
0
Update of /cvsroot/pure-data/externals/footils/fluid/fluid
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv13350
Modified Files:
main.cpp
Log Message:
Reset synth instance after soundfont loading. This finally lets fluid~ play
again immediatly after loading, yeah!
Index: main.cpp
===================================================================
RCS file: /cvsroot/pure-data/externals/footils/fluid/fluid/main.cpp,v
retrieving revision 1.5
retrieving revision 1.6
diff -C2 -d -r1.5 -r1.6
*** main.cpp 27 Jan 2004 10:13:57 -0000 1.5
--- main.cpp 20 Mar 2004 10:45:15 -0000 1.6
***************
*** 160,163 ****
--- 160,164 ----
{
post("Loaded Soundfont: %s", filename);
+ fluid_synth_program_reset(synth);
}
}
1
0
Update of /cvsroot/pure-data/externals/maxlib/src
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv2641/src
Added Files:
allow.c arbran.c arraycopy.c average.c beat.c beta.c bilex.c
borax.c cauchy.c chord.c delta.c deny.c dist.c divide.c
divmod.c edge.c expo.c fifo.c gauss.c gestalt.c history.c
ignore.c iso.c lifo.c limit.c linear.c listfifo.c listfunnel.c
match.c minus.c mlife.c multi.c nchange.c netclient.c
netdist.c netrec.c netserver.c nroute.c pitch.c plus.c
poisson.c pong.c pulse.c remote.c rewrap.c rhythm.c scale.c
score.c speedlim.c split.c step.c subst.c sync.c temperature.c
tilt.c timebang.c triang.c unroute.c urn.c velocity.c
weibull.c wrap.c
Log Message:
things back to Olaf's 1.5.2
--- NEW FILE: borax.c ---
/* ------------------------- borax ------------------------------------------ */
/* */
/* "swiss army knife" for music analysis. Inspired by 'borax' for Max. */
/* Written by Olaf Matthes (olaf.matthes(a)gmx.de) */
/* Get source at http://www.akustische-kunst.org/puredata/maxlib/ */
/* */
/* This program is free software; you can redistribute it and/or */
/* modify it under the terms of the GNU General Public License */
/* as published by the Free Software Foundation; either version 2 */
/* of the License, or (at your option) any later version. */
/* */
/* This program is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
/* GNU General Public License for more details. */
/* */
/* You should have received a copy of the GNU General Public License */
/* along with this program; if not, write to the Free Software */
/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/* */
/* Based on PureData by Miller Puckette and others. */
/* */
/* ---------------------------------------------------------------------------- */
#include "m_pd.h"
#define MAX_POLY 128 /* maximum number of notes played at a time */
static char *version = "borax v0.1, written by Olaf Matthes <olaf.matthes(a)gmx.de>";
typedef struct borax
{
t_object x_ob;
t_inlet *x_invelo; /* inlet for velocity */
t_inlet *x_inreset; /* inlet to reset the object */
t_outlet *x_outnotecount; /* counts notes */
t_outlet *x_outvoicealloc; /* assigns every note a unique number */
t_outlet *x_outpoly; /* number of notes playing (polyphony) */
t_outlet *x_outpitch; /* pitch of current note */
t_outlet *x_outvelo; /* velocity of current note */
t_outlet *x_outdurcount; /* number assigned to duration value */
t_outlet *x_outdurval; /* duration value */
t_outlet *x_outtimecount; /* number assigned to delta time value */
t_outlet *x_outtimeval; /* delta time value */
t_float x_notecount;
t_int x_pitch;
t_int x_velo;
t_float x_voicecount;
t_int x_voicealloc;
t_int x_poly;
t_float x_durcount;
t_float x_durval;
t_float x_timecount;
t_float x_timeval;
/* helpers needed to do the calculations */
double x_starttime[MAX_POLY];
double x_laststarttime;
t_int x_alloctable[MAX_POLY];
} t_borax;
static void borax_float(t_borax *x, t_floatarg f)
{
t_int velo = x->x_velo;
t_int allloc = 0;
int i;
x->x_pitch = (t_int)f;
if(velo == 0)
{
/* note off received... */
if(x->x_poly > 0)x->x_poly--; /* polyphony has decreased by one */
x->x_durcount++; /* we can calculate the duration */
for(i = 0; i < MAX_POLY; i++) /* search for voice allocation number */
{
/* search for corresponding alloc number */
if(x->x_alloctable[i] == x->x_pitch)
{
x->x_voicealloc = i;
x->x_alloctable[i] = 0; /* free the alloc number */
break;
}
/* couldn't find it ? */
if(i == MAX_POLY - 1)
{
post("borax: no corresponding note-on found (ignored)");
return;
}
}
x->x_durval = clock_gettimesince(x->x_starttime[x->x_voicealloc]);
}
else if(velo != 0)
{
/* note on received... */
x->x_poly++; /* number of currently playing notes has increased */
x->x_notecount++; /* total number of notes has increased */
/* assign a voice allocation number */
for(i = 0; i < MAX_POLY; i++)
{
/* search for free alloc number */
if(x->x_alloctable[i] == 0)
{
x->x_voicealloc = i; /* take the number */
x->x_alloctable[i] = x->x_pitch; /* ... and store pitch */
break;
}
/* couldn't find any ? */
if(i == MAX_POLY - 1)
{
post("borax: too many note-on messages (ignored)");
return;
}
}
/* calculate time in case it's not the first note */
if(x->x_notecount > 1)
{
x->x_timecount++;
x->x_timeval = clock_gettimesince(x->x_laststarttime);
}
/* save the new start time */
x->x_laststarttime = x->x_starttime[x->x_voicealloc] = clock_getlogicaltime();
}
/* output values from right to left */
outlet_float(x->x_outtimeval, x->x_timeval);
outlet_float(x->x_outtimecount, x->x_timecount);
outlet_float(x->x_outdurval, x->x_durval);
outlet_float(x->x_outdurcount, x->x_durcount);
outlet_float(x->x_outvelo, velo);
outlet_float(x->x_outpitch, x->x_pitch);
outlet_float(x->x_outpoly, x->x_poly);
outlet_float(x->x_outvoicealloc, x->x_voicealloc);
outlet_float(x->x_outnotecount, x->x_notecount);
}
static void borax_ft1(t_borax *x, t_floatarg f)
{
x->x_velo = (t_int)f;
}
static void borax_reset(t_borax *x)
{
int i;
post("borax: reset");
x->x_notecount = 0;
x->x_pitch = 0;
x->x_velo = 0;
x->x_voicecount = 0;
x->x_voicealloc = 0;
x->x_poly = 0;
x->x_durcount = 0;
x->x_durval = 0;
x->x_timecount = 0;
x->x_timeval = 0;
outlet_float(x->x_outtimeval, x->x_timeval);
outlet_float(x->x_outtimecount, x->x_timecount);
outlet_float(x->x_outdurval, x->x_durval);
outlet_float(x->x_outdurcount, x->x_durcount);
for(i = 0; i < MAX_POLY; i++)
{
if(x->x_alloctable[i] != 0)
{
x->x_poly--;
/* send note-off */
outlet_float(x->x_outvelo, 0);
outlet_float(x->x_outpitch, x->x_alloctable[i]);
outlet_float(x->x_outpoly, x->x_poly);
outlet_float(x->x_outvoicealloc, i);
}
x->x_alloctable[i] = 0;
}
outlet_float(x->x_outvelo, x->x_velo);
outlet_float(x->x_outpitch, x->x_pitch);
outlet_float(x->x_outpoly, x->x_poly);
outlet_float(x->x_outvoicealloc, x->x_voicealloc);
outlet_float(x->x_outnotecount, x->x_notecount);
}
static t_class *borax_class;
static void *borax_new(void)
{
int i;
t_borax *x = (t_borax *)pd_new(borax_class);
x->x_invelo = inlet_new(&x->x_ob, &x->x_ob.ob_pd, gensym("float"), gensym("ft1"));
x->x_inreset = inlet_new(&x->x_ob, &x->x_ob.ob_pd, gensym("bang"), gensym("ft2"));
x->x_outnotecount = outlet_new(&x->x_ob, gensym("float"));
x->x_outvoicealloc = outlet_new(&x->x_ob, gensym("float"));
x->x_outpoly = outlet_new(&x->x_ob, gensym("float"));
x->x_outpitch = outlet_new(&x->x_ob, gensym("float"));
x->x_outvelo = outlet_new(&x->x_ob, gensym("float"));
x->x_outdurcount = outlet_new(&x->x_ob, gensym("float"));
x->x_outdurval = outlet_new(&x->x_ob, gensym("float"));
x->x_outtimecount = outlet_new(&x->x_ob, gensym("float"));
x->x_outtimeval = outlet_new(&x->x_ob, gensym("float"));
for(i = 0; i < MAX_POLY; i++)x->x_alloctable[i] = 0;
x->x_notecount = 0;
x->x_pitch = 0;
x->x_velo = 0;
x->x_voicecount = 0;
x->x_voicealloc = 0;
x->x_poly = 0;
x->x_durcount = 0;
x->x_durval = 0;
x->x_timecount = 0;
x->x_timeval = 0;
return (void *)x;
}
#ifndef MAXLIB
void borax_setup(void)
{
borax_class = class_new(gensym("borax"), (t_newmethod)borax_new,
0, sizeof(t_borax), 0, 0);
#else
void maxlib_borax_setup(void)
{
borax_class = class_new(gensym("maxlib_borax"), (t_newmethod)borax_new,
0, sizeof(t_borax), 0, 0);
#endif
class_addmethod(borax_class, (t_method)borax_reset, gensym("reset"), 0);
class_addmethod(borax_class, (t_method)borax_ft1, gensym("ft1"), A_FLOAT, 0);
class_addmethod(borax_class, (t_method)borax_reset, gensym("ft2"), A_GIMME, 0);
class_addfloat(borax_class, borax_float);
#ifndef MAXLIB
class_sethelpsymbol(borax_class, gensym("help-borax.pd"));
post(version);
#else
class_addcreator((t_newmethod)borax_new, gensym("borax"), 0);
class_sethelpsymbol(borax_class, gensym("maxlib/help-borax.pd"));
#endif
}
--- NEW FILE: temperature.c ---
/* -------------------------- temperature ------------------------------------- */
/* */
/* Calculates temperature: number of 'events' within N milliseconds. */
/* Written by Olaf Matthes <olaf.matthes(a)gmx.de> */
/* Get source at http://www.akustische-kunst.org/puredata/maxlib/ */
/* */
/* This program is free software; you can redistribute it and/or */
/* modify it under the terms of the GNU General Public License */
/* as published by the Free Software Foundation; either version 2 */
/* of the License, or (at your option) any later version. */
/* */
/* This program is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
/* GNU General Public License for more details. */
/* */
/* You should have received a copy of the GNU General Public License */
/* along with this program; if not, write to the Free Software */
/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/* */
/* Based on PureData by Miller Puckette and others. */
/* */
/* ---------------------------------------------------------------------------- */
#include "m_pd.h"
#include <math.h>
static char *version = "temperature v0.1, written by Olaf Matthes <olaf.matthes(a)gmx.de>";
typedef struct temperature
{
t_object x_ob;
t_clock *x_clock;
t_outlet *x_outfloat; /* output the temperature */
t_int x_index; /* the number of elements to average */
t_int x_time;
} t_temperature;
static void temperature_tick(t_temperature *x)
{
outlet_float(x->x_outfloat, x->x_index);
x->x_index = 0;
clock_delay(x->x_clock, x->x_time);
}
static void temperature_float(t_temperature *x, t_floatarg f)
{
x->x_index++; /* just count number of 'events' */
}
static void temperature_anything(t_temperature *x, t_symbol *s, int argc, t_atom *argv)
{
x->x_index++; /* just count number of 'events' */
}
static void temperature_time(t_temperature *x, t_floatarg f)
{
x->x_time = (t_int)f;
if(x->x_time < 1) x->x_time = 1;
clock_unset(x->x_clock);
clock_delay(x->x_clock, x->x_time);
}
static void temperature_reset(t_temperature *x)
{
x->x_index = 0;
post("temperature: reset");
}
static void temperature_free(t_temperature *x)
{
clock_free(x->x_clock);
}
static t_class *temperature_class;
static void *temperature_new(t_floatarg f)
{
t_temperature *x = (t_temperature *)pd_new(temperature_class);
inlet_new(&x->x_ob, &x->x_ob.ob_pd, gensym("float"), gensym("time"));
x->x_outfloat = outlet_new(&x->x_ob, gensym("float"));
x->x_clock = clock_new(x, (t_method)temperature_tick);
x->x_time = (t_int)f;
if(x->x_time < 1)
{
x->x_time = 1;
post("temperature: set time to %d ms", x->x_time);
}
x->x_index = 0;
clock_delay(x->x_clock, x->x_time);
return (void *)x;
}
#ifndef MAXLIB
void temperature_setup(void)
{
temperature_class = class_new(gensym("temperature"), (t_newmethod)temperature_new,
(t_method)temperature_free, sizeof(t_temperature), 0, A_DEFFLOAT, 0);
class_addmethod(temperature_class, (t_method)temperature_reset, gensym("reset"), 0);
class_addfloat(temperature_class, temperature_float);
class_addmethod(temperature_class, (t_method)temperature_time, gensym("time"), A_FLOAT, 0);
class_addanything(temperature_class, temperature_anything);
class_sethelpsymbol(temperature_class, gensym("help-temperature.pd"));
post(version);
}
#else
void maxlib_temperature_setup(void)
{
temperature_class = class_new(gensym("maxlib_temperature"), (t_newmethod)temperature_new,
(t_method)temperature_free, sizeof(t_temperature), 0, A_DEFFLOAT, 0);
class_addcreator((t_newmethod)temperature_new, gensym("temperature"), A_DEFFLOAT, 0);
class_addmethod(temperature_class, (t_method)temperature_reset, gensym("reset"), 0);
class_addfloat(temperature_class, temperature_float);
class_addmethod(temperature_class, (t_method)temperature_time, gensym("time"), A_FLOAT, 0);
class_addanything(temperature_class, temperature_anything);
class_sethelpsymbol(temperature_class, gensym("maxlib/help-temperature.pd"));
}
#endif
--- NEW FILE: edge.c ---
/* --------------------------- edge ----------------------------------------- */
/* */
/* Detect rising or falling edge of float input. */
/* Written by Olaf Matthes (olaf.matthes(a)gmx.de) */
/* Get source at http://www.akustische-kunst.org/puredata/maxlib/ */
/* */
/* This program is free software; you can redistribute it and/or */
/* modify it under the terms of the GNU General Public License */
/* as published by the Free Software Foundation; either version 2 */
/* of the License, or (at your option) any later version. */
/* */
/* This program is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
/* GNU General Public License for more details. */
/* */
/* You should have received a copy of the GNU General Public License */
/* along with this program; if not, write to the Free Software */
/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/* */
/* Based on PureData by Miller Puckette and others. */
/* */
/* ---------------------------------------------------------------------------- */
#include "m_pd.h"
#include <stdio.h>
static char *version = "edge v0.1, written by Olaf Matthes <olaf.matthes(a)gmx.de>";
typedef struct edge
{
t_object x_ob;
t_outlet *x_out1; /* bang on rising edge */
t_outlet *x_out2; /* bang on falling edge */
t_float x_lastval; /* last input value */
} t_edge;
static void edge_float(t_edge *x, t_floatarg f)
{
if((x->x_lastval <= 0) && (f >= 1)) /* rising edge */
outlet_bang(x->x_out1);
else if((x->x_lastval >= 1) && (f <= 0)) /* falling edge */
outlet_bang(x->x_out2);
x->x_lastval = f; /* save last value */
}
static t_class *edge_class;
static void *edge_new(t_floatarg f)
{
int i;
t_edge *x = (t_edge *)pd_new(edge_class);
x->x_out1 = outlet_new(&x->x_ob, gensym("bang"));
x->x_out2 = outlet_new(&x->x_ob, gensym("bang"));
x->x_lastval = f;
return (void *)x;
}
#ifndef MAXLIB
void edge_setup(void)
{
edge_class = class_new(gensym("edge"), (t_newmethod)edge_new,
0, sizeof(t_edge), 0, A_DEFFLOAT, 0);
class_addfloat(edge_class, edge_float);
class_sethelpsymbol(edge_class, gensym("help-edge.pd"));
post(version);
}
#else
void maxlib_edge_setup(void)
{
edge_class = class_new(gensym("maxlib_edge"), (t_newmethod)edge_new,
0, sizeof(t_edge), 0, A_DEFFLOAT, 0);
class_addfloat(edge_class, edge_float);
class_addcreator((t_newmethod)edge_new, gensym("edge"), A_DEFFLOAT, 0);
class_sethelpsymbol(edge_class, gensym("maxlib/help-edge.pd"));
}
#endif
--- NEW FILE: iso.c ---
/* ---------------------------- iso ------------------------------------------- */
/* */
/* Queue up pitch and attack point series. */
/* Written by Olaf Matthes (olaf.matthes(a)gmx.de) */
/* Based on iso for Max by Charlie Baker (baker(a)foxtrot.ccmrc.ucsb.edu). */
/* Get source at http://www.akustische-kunst.org/puredata/maxlib/ */
/* */
/* This program is free software; you can redistribute it and/or */
/* modify it under the terms of the GNU General Public License */
/* as published by the Free Software Foundation; either version 2 */
/* of the License, or (at your option) any later version. */
/* */
/* This program is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
/* GNU General Public License for more details. */
/* */
/* You should have received a copy of the GNU General Public License */
/* along with this program; if not, write to the Free Software */
/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/* */
/* Based on PureData by Miller Puckette and others. */
/* */
/* ---------------------------------------------------------------------------- */
#include "m_pd.h"
#include <stdio.h>
#define MAXPOLY 32
static char *version = "iso v0.1, written for Max by Charlie Baker <baker(a)foxtrot.ccmrc.ucsb.edu>\n"
" ported to Pd by Olaf Matthes <olaf.matthes(a)gmx.de>";
/* Iso object data structure */
typedef struct iso
{
t_object iso_ob;
t_outlet *iso_out1; /* outlet 1*/
t_outlet *iso_out2; /* outlet 2*/
t_inlet *iso_in2; /* inlet 2 (attack list) */
t_clock *iso_clock;
t_int ptchlength,atklength,curptch,curatk;
t_float pitches[MAXPOLY];
t_float atks[MAXPOLY];
t_int loop,stop;
t_float hook,duty;
} t_iso;
static t_class *iso_class;
/* take list and create matrix */
static void iso_bang(t_iso *x)
{
x->stop = 0;
x->curptch = 0;
x->curatk = 0;
clock_delay(x->iso_clock, 0);
}
static void iso_clock_fun(t_iso *x)
{
if (!x->stop) {
clock_delay(x->iso_clock, (double)(x->atks[x->curatk] * x->hook));
outlet_float(x->iso_out2,(t_float)(x->atks[x->curatk] * x->hook * x->duty));
outlet_float(x->iso_out1,x->pitches[x->curptch] );
if (x->loop) {
x->curatk = ((x->curatk + 1) % x->atklength);
x->curptch = ((x->curptch + 1) % x->ptchlength);
}
else {
if (((x->curatk + 1) >= x->atklength) || ((x->curptch + 1) >= x->ptchlength))
x->stop = 1;
else {
x->curptch += 1;
x->curatk += 1;
}
}
}
}
static void iso_hook(t_iso *x, t_floatarg hook)
{
if (hook < 1.0) hook = 1.0;
x->hook = (t_float)hook;
}
static void iso_duty(t_iso *x, t_floatarg duty)
{
if (duty < 1.0) duty = 1.0;
x->duty = (t_float)duty;
}
static void iso_list(t_iso *x, t_symbol *s, t_int argc, t_atom* argv)
{
int i;
if (argc > MAXPOLY) post("iso: only %d values max. allowed in list!", MAXPOLY);
for (i = 0; i < argc; i++) x->atks[i] = argv[i].a_w.w_float;
x->atklength = argc;
}
static void iso_pitch(t_iso *x, t_symbol *s, t_int argc, t_atom* argv)
{
int i;
if (argc > MAXPOLY) post("iso: only %d values max. allowed in list!", MAXPOLY);
for (i = 0; i < argc; i++) x->pitches[i] = argv[i].a_w.w_float;
x->ptchlength = argc;
}
static void iso_start(t_iso *x, t_symbol *s, t_int argc, t_atom* argv)
{
t_int start = atom_getfloatarg(0, argc, argv);
x->stop = 0;
if (start) {
x->curptch = (t_int)((start - 1) % x->ptchlength);
x->curatk = (t_int)((start - 1) % x->atklength);
}
else {
x->curptch = 0;
x->curatk = 0;
}
clock_delay(x->iso_clock, 0);
}
static void iso_stop(t_iso *x)
{
x->stop = 1;
x->curatk = 0;
x->curptch = 0;
}
static void iso_pause(t_iso *x)
{
x->stop = 1;
}
static void iso_loop(t_iso *x)
{
x->loop = 1;
}
static void iso_resume(t_iso *x)
{
x->stop = 0;
clock_delay(x->iso_clock, 0);
}
static void iso_unloop(t_iso *x)
{
x->loop = 0;
}
static void *iso_new(void) {
t_iso *x = (t_iso *)pd_new(iso_class); /* allocates memory and sticks in an inlet */
x->iso_clock = clock_new(x, (t_method)iso_clock_fun);
x->iso_out1 = outlet_new(&x->iso_ob, gensym("float"));
x->iso_out2 = outlet_new(&x->iso_ob, gensym("float"));
x->iso_in2 = inlet_new(&x->iso_ob, &x->iso_ob.ob_pd, gensym("list"), gensym("attack"));
x->stop = 0;
x->loop = 1;
x->hook = 1.0;
x->curptch = 0;
x->curatk = 0;
x->ptchlength = 1;
x->atklength = 1;
x->pitches[0] = 60;
x->atks[0] = 500;
x->duty = 1.0;
return (x); /* always return a copy of the created object */
}
static void iso_free(t_iso *x) {
clock_free(x->iso_clock);
}
#ifndef MAXLIB
void iso_setup(void) {
iso_class = class_new(gensym("iso"), (t_newmethod)iso_new,
(t_method)iso_free, sizeof(t_iso), 0, 0);
class_addmethod(iso_class, (t_method)iso_duty, gensym("duty"), A_FLOAT, 0);
class_addmethod(iso_class, (t_method)iso_list, gensym("attack"), A_GIMME, 0);
class_addmethod(iso_class, (t_method)iso_start, gensym("start"), A_GIMME, 0);
class_addmethod(iso_class, (t_method)iso_stop, gensym("stop"), 0);
class_addmethod(iso_class, (t_method)iso_pause, gensym("pause"), 0);
class_addmethod(iso_class, (t_method)iso_loop, gensym("loop"), 0);
class_addmethod(iso_class, (t_method)iso_unloop, gensym("unloop"), 0);
class_addmethod(iso_class, (t_method)iso_resume, gensym("resume"), 0);
class_addmethod(iso_class, (t_method)iso_hook, gensym("hook"), A_FLOAT, 0);
class_addbang(iso_class, iso_bang);
class_addlist(iso_class, iso_pitch);
class_sethelpsymbol(iso_class, gensym("help-iso.pd"));
post(version);
}
#else
void maxlib_iso_setup(void) {
iso_class = class_new(gensym("maxlib_iso"), (t_newmethod)iso_new,
(t_method)iso_free, sizeof(t_iso), 0, 0);
class_addcreator((t_newmethod)iso_new, gensym("iso"), 0);
class_addmethod(iso_class, (t_method)iso_duty, gensym("duty"), A_FLOAT, 0);
class_addmethod(iso_class, (t_method)iso_list, gensym("attack"), A_GIMME, 0);
class_addmethod(iso_class, (t_method)iso_start, gensym("start"), A_GIMME, 0);
class_addmethod(iso_class, (t_method)iso_stop, gensym("stop"), 0);
class_addmethod(iso_class, (t_method)iso_pause, gensym("pause"), 0);
class_addmethod(iso_class, (t_method)iso_loop, gensym("loop"), 0);
class_addmethod(iso_class, (t_method)iso_unloop, gensym("unloop"), 0);
class_addmethod(iso_class, (t_method)iso_resume, gensym("resume"), 0);
class_addmethod(iso_class, (t_method)iso_hook, gensym("hook"), A_FLOAT, 0);
class_addbang(iso_class, iso_bang);
class_addlist(iso_class, iso_pitch);
class_sethelpsymbol(iso_class, gensym("maxlib/help-iso.pd"));
}
#endif
--- NEW FILE: triang.c ---
/* ---------------------------- rand_triang ----------------------------------- */
/* */
/* rand_triang generates a triangularly distributed random variable. */
/* Written by Olaf Matthes (olaf.matthes(a)gmx.de) */
/* Based on code found in Dodge/Jerse "Computer Music" */
/* Get source at http://www.akustische-kunst.org/puredata/maxlib/ */
/* */
/* This program is free software; you can redistribute it and/or */
/* modify it under the terms of the GNU General Public License */
/* as published by the Free Software Foundation; either version 2 */
/* of the License, or (at your option) any later version. */
/* */
/* This program is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
/* GNU General Public License for more details. */
/* */
/* You should have received a copy of the GNU General Public License */
/* along with this program; if not, write to the Free Software */
/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/* */
/* Based on PureData by Miller Puckette and others. */
/* */
/* ---------------------------------------------------------------------------- */
#include "m_pd.h"
#include <stdlib.h>
#include <time.h>
#include <math.h>
#define fran() (t_float)rand()/(t_float)RAND_MAX
static char *version = "triang v0.1, generates triangularly distributed random variable\n"
" written by Olaf Matthes <olaf.matthes(a)gmx.de>";
/* -------------------------- rand_triang ------------------------------ */
static t_class *rand_triang_class;
typedef struct _rand_triang
{
t_object x_obj;
} t_rand_triang;
static void *rand_triang_new(t_floatarg f)
{
t_rand_triang *x = (t_rand_triang *)pd_new(rand_triang_class);
srand( (unsigned)time( NULL ) );
outlet_new(&x->x_obj, &s_float);
return (x);
}
static void rand_triang_bang(t_rand_triang *x)
{
t_float u1, u2;
u1 = fran();
u2 = fran();
outlet_float(x->x_obj.ob_outlet, 0.5*(u1+u2));
}
#ifndef MAXLIB
void triang_setup(void)
{
rand_triang_class = class_new(gensym("triang"), (t_newmethod)rand_triang_new, 0,
sizeof(t_rand_triang), 0, A_DEFFLOAT, 0);
#else
void maxlib_triang_setup(void)
{
rand_triang_class = class_new(gensym("maxlib_triang"), (t_newmethod)rand_triang_new, 0,
sizeof(t_rand_triang), 0, A_DEFFLOAT, 0);
class_addcreator((t_newmethod)rand_triang_new, gensym("triang"), A_DEFFLOAT, 0);
#endif
class_addbang(rand_triang_class, rand_triang_bang);
#ifndef MAXLIB
class_sethelpsymbol(rand_triang_class, gensym("help-triang.pd"));
post(version);
#else
class_sethelpsymbol(rand_triang_class, gensym("maxlib/help-triang.pd"));
#endif
}
--- NEW FILE: gauss.c ---
/* ---------------------------- rand_gauss ----------------------------------- */
/* */
/* rand_gauss generates a gauss distributed random variable. */
/* Written by Olaf Matthes (olaf.matthes(a)gmx.de) */
/* Based on code found in Dodge/Jerse "Computer Music" */
/* Get source at http://www.akustische-kunst.org/puredata/maxlib/ */
/* */
/* This program is free software; you can redistribute it and/or */
/* modify it under the terms of the GNU General Public License */
/* as published by the Free Software Foundation; either version 2 */
/* of the License, or (at your option) any later version. */
/* */
/* This program is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
/* GNU General Public License for more details. */
/* */
/* You should have received a copy of the GNU General Public License */
/* along with this program; if not, write to the Free Software */
/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/* */
/* Based on PureData by Miller Puckette and others. */
/* */
/* ---------------------------------------------------------------------------- */
#include "m_pd.h"
#include <stdlib.h>
#include <time.h>
#include <math.h>
#define fran() (t_float)rand()/(t_float)RAND_MAX
static char *version = "gauss v0.1, generates a Gaussian distributed random variable\n"
" with mean 'mu' and standard deviation 'sigma',\n"
" written by Olaf Matthes <olaf.matthes(a)gmx.de>";
/* -------------------------- rand_gauss ------------------------------ */
static t_class *rand_gauss_class;
typedef struct _rand_gauss
{
t_object x_obj;
t_float x_sigma;
t_float x_mu;
} t_rand_gauss;
static void *rand_gauss_new(t_floatarg fs, t_floatarg fm)
{
t_rand_gauss *x = (t_rand_gauss *)pd_new(rand_gauss_class);
srand( (unsigned)time( NULL ) );
floatinlet_new(&x->x_obj, &x->x_sigma);
floatinlet_new(&x->x_obj, &x->x_mu);
outlet_new(&x->x_obj, &s_float);
x->x_sigma = fs;
return (x);
}
static void rand_gauss_bang(t_rand_gauss *x)
{
t_float u, halfN = 6.0, sum = 0, scale;
t_int k, N = 12;
scale = 1/sqrt(N/12);
for(k = 1; k <= N; k++)
sum += fran();
outlet_float(x->x_obj.ob_outlet, x->x_sigma*scale*(sum-halfN)+x->x_mu);
}
#ifndef MAXLIB
void gauss_setup(void)
{
rand_gauss_class = class_new(gensym("gauss"), (t_newmethod)rand_gauss_new, 0,
sizeof(t_rand_gauss), 0, A_DEFFLOAT, A_DEFFLOAT, 0);
class_addbang(rand_gauss_class, rand_gauss_bang);
class_sethelpsymbol(rand_gauss_class, gensym("help-gauss.pd"));
post(version);
}
#else
void maxlib_gauss_setup(void)
{
rand_gauss_class = class_new(gensym("maxlib_gauss"), (t_newmethod)rand_gauss_new, 0,
sizeof(t_rand_gauss), 0, A_DEFFLOAT, A_DEFFLOAT, 0);
class_addcreator((t_newmethod)rand_gauss_new, gensym("gauss"), A_DEFFLOAT, 0);
class_addbang(rand_gauss_class, rand_gauss_bang);
class_sethelpsymbol(rand_gauss_class, gensym("maxlib/help-gauss.pd"));
}
#endif
--- NEW FILE: nchange.c ---
/* ------------------------- ignore ------------------------------------------- */
/* */
/* A 'new' change object for more than just floats. */
/* Written by Olaf Matthes <olaf.matthes(a)gmx.de> */
/* Get source at http://www.akustische-kunst.org/puredata/maxlib/ */
/* */
/* This program is free software; you can redistribute it and/or */
/* modify it under the terms of the GNU General Public License */
/* as published by the Free Software Foundation; either version 2 */
/* of the License, or (at your option) any later version. */
/* */
/* This program is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
/* GNU General Public License for more details. */
/* */
/* You should have received a copy of the GNU General Public License */
/* along with this program; if not, write to the Free Software */
/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/* */
/* Based on PureData by Miller Puckette and others. */
/* */
/* ---------------------------------------------------------------------------- */
#define A_LIST 254;
#define A_ANYTHING 255;
#include "m_pd.h"
// #include <string.h>
// #include <stdio.h>
/* -------------------------- nchange ------------------------------ */
static char *version = "nchange v0.1, written by Olaf Matthes <olaf.matthes(a)gmx.de>";
static t_class *nchange_class;
typedef struct _nchange
{
t_object x_obj;
t_atom x_a[256];
int x_c;
int x_type;
} t_nchange;
static void *nchange_new(t_symbol *s)
{
int i;
t_nchange *x = (t_nchange *)pd_new(nchange_class);
if(s == gensym("s"))
{
x->x_type = A_SYMBOL;
outlet_new(&x->x_obj, &s_symbol);
}
else if(s == gensym("f"))
{
x->x_type = A_FLOAT;
outlet_new(&x->x_obj, &s_float);
}
else if(s == gensym("l"))
{
x->x_type = A_LIST;
outlet_new(&x->x_obj, &s_list);
}
else
{
x->x_type = A_ANYTHING;
outlet_new(&x->x_obj, &s_anything);
}
return (x);
}
static void nchange_bang(t_nchange *x)
{
if (x->x_type == A_FLOAT)
outlet_float(x->x_obj.ob_outlet, x->x_a->a_w.w_float);
else if (x->x_type == A_SYMBOL)
outlet_symbol(x->x_obj.ob_outlet, x->x_a->a_w.w_symbol);
else
outlet_list(x->x_obj.ob_outlet, NULL, x->x_c, x->x_a);
}
static void nchange_float(t_nchange *x, t_float f)
{
if (x->x_type == A_FLOAT)
{
if (f != x->x_a->a_w.w_float)
{
// x->x_f = f;
SETFLOAT(x->x_a, f);
outlet_float(x->x_obj.ob_outlet, x->x_a->a_w.w_float);
}
}
}
static void nchange_symbol(t_nchange *x, t_symbol *s)
{
if (x->x_type == A_SYMBOL)
{
if (s != x->x_a->a_w.w_symbol)
{
// x->x_s = s;
SETSYMBOL(x->x_a, s);
outlet_symbol(x->x_obj.ob_outlet, x->x_a->a_w.w_symbol);
}
}
}
static void nchange_list(t_nchange *x, t_symbol *s, int argc, t_atom *argv)
{
int i, change = 0;
int c = argc;
if(c == x->x_c) // same number of elements
for (i = 0; i < c; i++)
{
/* if(x->x_a[i].a_type != argv[i].a_type)
{
change = 1;
break;
} */
if (x->x_a[i].a_type == A_FLOAT)
{
if (argv[i].a_type != A_FLOAT || x->x_a[i].a_w.w_float != argv[i].a_w.w_float)
{
change = 1;
break;
}
}
else if (x->x_a[i].a_type == A_SYMBOL)
{
if (argv[i].a_type != A_SYMBOL || x->x_a[i].a_w.w_symbol != argv[i].a_w.w_symbol)
{
change = 1;
break;
}
}
}
else change = 1; // different number of elems.
if (change)
{
x->x_c = c;
for (i = 0; i < c; i++) // same new list
{
x->x_a[i] = argv[i];
}
outlet_list(x->x_obj.ob_outlet, s, argc, argv);
}
}
static void nchange_set(t_nchange *x, t_symbol *s, int argc, t_atom *argv)
{
int i;
if (x->x_type == A_SYMBOL)
{
SETSYMBOL(x->x_a, argv->a_w.w_symbol);
}
else if (x->x_type == A_FLOAT)
{
SETFLOAT(x->x_a, argv->a_w.w_float);
}
else // list or anything
{
x->x_c = argc;
for (i = 0; i < argc; i++)
{
x->x_a[i] = argv[i];
}
}
}
#ifndef MAXLIB
void nchange_setup(void)
{
nchange_class = class_new(gensym("nchange"), (t_newmethod)nchange_new, 0,
sizeof(t_nchange), 0, A_SYMBOL, 0);
class_addbang(nchange_class, nchange_bang);
class_addfloat(nchange_class, nchange_float);
class_addsymbol(nchange_class, nchange_symbol);
class_addlist(nchange_class, nchange_list);
class_addanything(nchange_class, nchange_list);
class_addmethod(nchange_class, (t_method)nchange_set, gensym("set"), A_GIMME, 0);
class_sethelpsymbol(nchange_class, gensym("help-nchange.pd"));
post(version);
}
#else
void maxlib_nchange_setup(void)
{
nchange_class = class_new(gensym("maxlib_nchange"), (t_newmethod)nchange_new, 0,
sizeof(t_nchange), 0, A_SYMBOL, 0);
class_addcreator((t_newmethod)nchange_new, gensym("nchange"), A_SYMBOL, 0);
class_addbang(nchange_class, nchange_bang);
class_addfloat(nchange_class, nchange_float);
class_addsymbol(nchange_class, nchange_symbol);
class_addlist(nchange_class, nchange_list);
class_addanything(nchange_class, nchange_list);
class_addmethod(nchange_class, (t_method)nchange_set, gensym("set"), A_GIMME, 0);
class_sethelpsymbol(nchange_class, gensym("maxlib/help-nchange.pd"));
}
#endif
--- NEW FILE: wrap.c ---
/* ------------------------- wrap ------------------------------------------ */
/* */
/* wraps input to lie within an output range. */
/* Written by Olaf Matthes <olaf.matthes(a)gmx.de> */
/* Get source at http://www.akustische-kunst.org/puredata/maxlib/ */
/* */
/* This program is free software; you can redistribute it and/or */
/* modify it under the terms of the GNU General Public License */
/* as published by the Free Software Foundation; either version 2 */
/* of the License, or (at your option) any later version. */
/* */
/* This program is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
/* GNU General Public License for more details. */
/* */
/* You should have received a copy of the GNU General Public License */
/* along with this program; if not, write to the Free Software */
/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/* */
/* Based on PureData by Miller Puckette and others. */
/* */
/* ---------------------------------------------------------------------------- */
#include "m_pd.h"
#include <stdio.h>
#include <math.h>
static char *version = "wrap v0.1, written by Olaf Matthes <olaf.matthes(a)gmx.de>";
typedef struct wrap
{
t_object x_ob;
t_float x_min; /* low border of input range */
t_float x_max; /* high border of input range */
t_outlet *x_outlet1; /* path-through outlet */
t_outlet *x_outlet2; /* wrap outlet */
} t_wrap;
static void wrap_float(t_wrap *x, t_floatarg f)
{
t_float min = x->x_min;
t_float max = x->x_max;
t_float range = max - min;
t_int i;
if(range == 0.0f)
{
f = min;
outlet_float(x->x_outlet2, 0);
}
else if(f < min)
{
t_float diff = min - f;
t_float n = ceil(diff / range);
f += n * range;
outlet_float(x->x_outlet2, -(t_int)n);
}
else if (f >= max)
{
t_float diff = f - max;
t_float n = floor(diff / range) + 1.0f;
f -= n * range;
outlet_float(x->x_outlet2, (t_int)n);
}
else
outlet_float(x->x_outlet2, 0.0f);
outlet_float(x->x_outlet1, f);
}
static void wrap_a(t_wrap *x, t_floatarg a)
{
t_float max = x->x_max;
if(a <= max)
x->x_min = a;
else
{
x->x_min = max;
x->x_max = a;
}
}
static void wrap_b(t_wrap *x, t_floatarg b)
{
t_float min = x->x_min;
if(b >= min)
x->x_max = b;
else
{
x->x_max = min;
x->x_min = b;
}
}
static t_class *wrap_class;
static void *wrap_new(t_floatarg fmin, t_floatarg fmax)
{
t_wrap *x = (t_wrap *)pd_new(wrap_class);
inlet_new(&x->x_ob, &x->x_ob.ob_pd, gensym("float"), gensym("a"));
inlet_new(&x->x_ob, &x->x_ob.ob_pd, gensym("float"), gensym("b"));
x->x_outlet1 = outlet_new(&x->x_ob, gensym("float"));
x->x_outlet2 = outlet_new(&x->x_ob, gensym("float"));
x->x_min = fmin;
wrap_b(x, fmax);
return (void *)x;
}
#ifndef MAXLIB
void wrap_setup(void)
{
wrap_class = class_new(gensym("wrap"), (t_newmethod)wrap_new,
0, sizeof(t_wrap), 0, A_DEFFLOAT, A_DEFFLOAT, 0);
#else
void maxlib_wrap_setup(void)
{
wrap_class = class_new(gensym("maxlib_wrap"), (t_newmethod)wrap_new,
0, sizeof(t_wrap), 0, A_DEFFLOAT, A_DEFFLOAT, 0);
class_addcreator((t_newmethod)wrap_new, gensym("wrap"), A_DEFFLOAT, A_DEFFLOAT, 0);
#endif
class_addfloat(wrap_class, wrap_float);
class_addmethod(wrap_class, (t_method)wrap_a, gensym("a"), A_FLOAT, 0);
class_addmethod(wrap_class, (t_method)wrap_b, gensym("b"), A_FLOAT, 0);
#ifndef MAXLIB
class_sethelpsymbol(wrap_class, gensym("help-wrap.pd"));
post(version);
#else
class_sethelpsymbol(wrap_class, gensym("maxlib/help-wrap.pd"));
#endif
}
--- NEW FILE: ignore.c ---
/* ------------------------- ignore ------------------------------------------- */
/* */
/* Ignores input that is followed by next value faster than N ms. */
/* Written by Olaf Matthes (olaf.matthes(a)gmx.de) */
/* Get source at http://www.akustische-kunst.org/puredata/maxlib/ */
/* */
/* This program is free software; you can redistribute it and/or */
/* modify it under the terms of the GNU General Public License */
/* as published by the Free Software Foundation; either version 2 */
/* of the License, or (at your option) any later version. */
/* */
/* This program is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
/* GNU General Public License for more details. */
/* */
/* You should have received a copy of the GNU General Public License */
/* along with this program; if not, write to the Free Software */
/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/* */
/* Based on PureData by Miller Puckette and others. */
/* */
/* ---------------------------------------------------------------------------- */
#include "m_pd.h"
static char *version = "ignore v0.1, written by Olaf Matthes <olaf.matthes(a)gmx.de>";
typedef struct ignore
{
t_object x_ob;
t_clock *x_clock;
t_inlet *x_intime;
t_outlet *x_outfloat;
t_float x_input;
t_float x_lastinput;
t_int x_limit; /* indicates if input is 'blocked' (1) */
t_int x_time; /* the time in ms */
} t_ignore;
static void ignore_tick(t_ignore *x)
{
x->x_limit = 0;
/* output in case nothing has changed */
if(x->x_lastinput == x->x_input)
outlet_float(x->x_outfloat, x->x_lastinput);
}
static void ignore_float(t_ignore *x, t_floatarg f)
{
x->x_input = f;
if(!x->x_limit)
{
x->x_limit = 1; /* ignore input within next N ms */
clock_delay(x->x_clock, x->x_time); /* start clock */
}
else /* ignore / start clock again */
{
x->x_lastinput = x->x_input; /* save current as last valid value */
clock_unset(x->x_clock); /* throw out last clock */
clock_delay(x->x_clock, x->x_time); /* start new clock */
}
}
static void ignore_time(t_ignore *x, t_floatarg f)
{
x->x_time = (t_int)f;
}
static void ignore_reset(t_ignore *x)
{
x->x_limit = 0;
post("ignore: reset");
}
static void ignore_free(t_ignore *x)
{
clock_free(x->x_clock);
}
static t_class *ignore_class;
static void *ignore_new(t_floatarg f)
{
t_ignore *x = (t_ignore *)pd_new(ignore_class);
x->x_intime = inlet_new(&x->x_ob, &x->x_ob.ob_pd, gensym("float"), gensym("time"));
x->x_outfloat = outlet_new(&x->x_ob, gensym("float"));
x->x_clock = clock_new(x, (t_method)ignore_tick);
x->x_time = (t_int)f;
x->x_lastinput = 0;
return (void *)x;
}
#ifndef MAXLIB
void ignore_setup(void)
{
ignore_class = class_new(gensym("ignore"), (t_newmethod)ignore_new,
(t_method)ignore_free, sizeof(t_ignore), 0, A_DEFFLOAT, 0);
class_addmethod(ignore_class, (t_method)ignore_reset, gensym("reset"), 0);
class_addmethod(ignore_class, (t_method)ignore_time, gensym("time"), A_FLOAT, 0);
class_addfloat(ignore_class, ignore_float);
class_sethelpsymbol(ignore_class, gensym("help-ignore.pd"));
post(version);
}
#else
void maxlib_ignore_setup(void)
{
ignore_class = class_new(gensym("maxlib_ignore"), (t_newmethod)ignore_new,
(t_method)ignore_free, sizeof(t_ignore), 0, A_DEFFLOAT, 0);
class_addcreator((t_newmethod)ignore_new, gensym("ignore"), A_DEFFLOAT, 0);
class_addmethod(ignore_class, (t_method)ignore_reset, gensym("reset"), 0);
class_addmethod(ignore_class, (t_method)ignore_time, gensym("time"), A_FLOAT, 0);
class_addfloat(ignore_class, ignore_float);
class_sethelpsymbol(ignore_class, gensym("maxlib/help-ignore.pd"));
}
#endif
--- NEW FILE: unroute.c ---
/* -------------------------- unroute ------------------------------------- */
/* */
/* Opposit to croute. */
/* Written by Olaf Matthes <olaf.matthes(a)gmx.de> */
/* Get source at http://www.akustische-kunst.org/puredata/ */
/* */
/* This program is free software; you can redistribute it and/or */
/* modify it under the terms of the GNU General Public License */
/* as published by the Free Software Foundation; either version 2 */
/* of the License, or (at your option) any later version. */
/* */
/* This program is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
/* GNU General Public License for more details. */
/* */
/* You should have received a copy of the GNU General Public License */
/* along with this program; if not, write to the Free Software */
/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/* */
/* Based on PureData by Miller Puckette and others. */
/* */
/* ---------------------------------------------------------------------------- */
#include "m_pd.h"
#define MAX_INLET 256
static char *version = "unroute v0.1, written by Olaf Matthes <olaf.matthes(a)gmx.de>";
typedef struct unroute
{
t_object x_obj;
t_outlet *x_outlet;
t_int x_ninstance;
t_atom x_id;
} t_unroute;
typedef struct proxy
{
t_object obj;
t_int index; /* number of proxy inlet(s) */
t_atom id;
t_unroute *x; /* we'll put the other struct in here */
} t_proxy;
static void unroute_any(t_unroute *x, t_symbol *s, int argc, t_atom *argv)
{
int i;
t_atom at[MAXPDSTRING];
for(i = 0; i < argc; i++)
{
at[i + 2] = argv[i];
}
argc += 2;
SETSYMBOL(at+1, s);
at[0] = x->x_id; /* prepend id of that inlet */
outlet_list(x->x_outlet, NULL, argc, at);
}
static void unroute_list(t_unroute *x, t_symbol *s, int argc, t_atom *argv)
{
int i;
t_atom at[MAXPDSTRING];
for(i = 0; i < argc; i++)
{
at[i + 1] = argv[i];
}
argc++;
at[0] = x->x_id; /* prepend id of that inlet */
outlet_list(x->x_outlet, NULL, argc, at);
}
static void unroute_float(t_unroute *x, t_floatarg f)
{
t_atom list[2];
list[0] = x->x_id; /* prepend id of that inlet */
SETFLOAT(list+1, f);
outlet_list(x->x_outlet, NULL, 2, list);
}
static void unroute_input(t_proxy *p, t_symbol *s, int argc, t_atom *argv)
{
t_unroute *x = (t_unroute *)(p->x);
int i;
t_atom at[MAXPDSTRING];
if(s == gensym("list"))
{
for(i = 0; i < argc; i++)
{
at[i + 1] = argv[i];
}
argc++;
}
else
{
for(i = 0; i < argc; i++)
{
at[i + 2] = argv[i];
}
argc += 2;
SETSYMBOL(at+1, s);
}
at[0] = p->id; /* prepend id for that inlet */
outlet_list(x->x_outlet, NULL, argc, at);
}
static t_class *unroute_class;
static t_class *proxy_class;
static void *unroute_new(t_symbol *s, int argc, t_atom *argv)
{
int i;
t_unroute *x = (t_unroute *)pd_new(unroute_class);
t_proxy *inlet[MAX_INLET];
x->x_ninstance = argc;
x->x_id = argv[0];
for(i = 0; i < x->x_ninstance - 1; i++)
{
inlet[i] = (t_proxy *)pd_new(proxy_class);
inlet[i]->x = x; /* make x visible to the proxy inlets */
inlet[i]->index = i; /* remember our number */
inlet[i]->id = argv[i+1];
/* the inlet we're going to create belongs to the object
't_unroute' but the destination is the instance 'i'
of the proxy class 't_proxy' */
inlet_new(&x->x_obj, &inlet[i]->obj.ob_pd, 0,0);
}
x->x_outlet = outlet_new(&x->x_obj, gensym("float"));
return (void *)x;
}
#ifndef MAXLIB
void unroute_setup(void)
{
unroute_class = class_new(gensym("unroute"), (t_newmethod)unroute_new,
0, sizeof(t_unroute), 0, A_GIMME, 0);
#else
void maxlib_unroute_setup(void)
{
unroute_class = class_new(gensym("maxlib_unroute"), (t_newmethod)unroute_new,
0, sizeof(t_unroute), 0, A_GIMME, 0);
#endif
/* a class for the proxy inlet: */
proxy_class = class_new(gensym("maxlib_unroute_proxy"), NULL, NULL, sizeof(t_proxy),
CLASS_PD|CLASS_NOINLET, A_NULL);
class_addanything(proxy_class, unroute_input);
class_addfloat(unroute_class, unroute_float);
class_addlist(unroute_class, unroute_list);
class_addanything(unroute_class, unroute_any);
#ifndef MAXLIB
class_sethelpsymbol(unroute_class, gensym("help-unroute.pd"));
post(version);
#else
class_addcreator((t_newmethod)unroute_new, gensym("unroute"), A_GIMME, 0);
class_sethelpsymbol(unroute_class, gensym("maxlib/help-unroute.pd"));
#endif
}
--- NEW FILE: limit.c ---
/* ------------------------- limit ------------------------------------------ */
/* */
/* limits input to lie within an output range. */
/* Written by Olaf Matthes <olaf.matthes(a)gmx.de> */
/* Get source at http://www.akustische-kunst.org/puredata/maxlib/ */
/* */
/* This program is free software; you can redistribute it and/or */
/* modify it under the terms of the GNU General Public License */
/* as published by the Free Software Foundation; either version 2 */
/* of the License, or (at your option) any later version. */
/* */
/* This program is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
/* GNU General Public License for more details. */
/* */
/* You should have received a copy of the GNU General Public License */
/* along with this program; if not, write to the Free Software */
/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/* */
/* Based on PureData by Miller Puckette and others. */
/* */
/* ---------------------------------------------------------------------------- */
#include "m_pd.h"
#include <stdio.h>
#include <math.h>
static char *version = "limit v0.1, written by Olaf Matthes <olaf.matthes(a)gmx.de>";
typedef struct limit
{
t_object x_ob;
t_float x_ol; /* low border of output range */
t_float x_oh; /* high border of output range */
t_float x_ratio; /* 'compression ratio' */
t_outlet *x_outlet1; /* result */
t_float x_f;
} t_limit;
static void limit_float(t_limit *x, t_floatarg f)
{
if(x->x_oh < x->x_ol) /* swap values */
{
int i = x->x_oh;
x->x_oh = x->x_ol;
x->x_ol = i;
}
if(x->x_ratio == 0) /* 'clip' mode */
{
if(f > x->x_oh)f = x->x_oh;
else if(f < x->x_ol)f = x->x_ol;
}
else /* 'compress' mode */
{
int diff;
if(f > x->x_oh)
{
diff = f - x->x_oh;
f = x->x_oh + (diff / x->x_ratio);
}
else if(f < x->x_ol)
{
diff = x->x_ol - f;
f = x->x_ol - (diff / x->x_ratio);
}
}
outlet_float(x->x_outlet1, f);
x->x_f = f;
}
static void limit_bang(t_limit *x)
{
limit_float(x, x->x_f); /* recalculate result */
}
static t_class *limit_class;
static void *limit_new(t_floatarg fol, t_floatarg foh, t_floatarg fr)
{
t_limit *x = (t_limit *)pd_new(limit_class);
floatinlet_new(&x->x_ob, &x->x_ol);
floatinlet_new(&x->x_ob, &x->x_oh);
floatinlet_new(&x->x_ob, &x->x_ratio);
x->x_outlet1 = outlet_new(&x->x_ob, gensym("float"));
/* default values taken from Max's limit */
x->x_ol = fol;
x->x_oh = foh;
if(x->x_oh < x->x_ol) /* swap values */
{
int i = x->x_oh;
x->x_oh = x->x_ol;
x->x_ol = i;
}
x->x_ratio = fr;
x->x_f = 0;
return (void *)x;
}
#ifndef MAXLIB
void limit_setup(void)
{
limit_class = class_new(gensym("limit"), (t_newmethod)limit_new,
0, sizeof(t_limit), 0, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0);
#else
void maxlib_limit_setup(void)
{
limit_class = class_new(gensym("maxlib_limit"), (t_newmethod)limit_new,
0, sizeof(t_limit), 0, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0);
class_addcreator((t_newmethod)limit_new, gensym("limit"), A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0);
#endif
class_addfloat(limit_class, limit_float);
class_addbang(limit_class, limit_bang);
#ifndef MAXLIB
class_sethelpsymbol(limit_class, gensym("help-limit.pd"));
post(version);
#else
class_sethelpsymbol(limit_class, gensym("maxlib/help-limit.pd"));
#endif
}
--- NEW FILE: netrec.c ---
/* -------------------------- netrec ---------------------------------------- */
/* */
/* A 'netreceive' that tells the IP of the connecting netsend. */
/* Written by Olaf Matthes <olaf.matthes(a)gmx.de> */
/* Get source at http://www.akustische-kunst.org/puredata/maxlib/ */
/* */
/* This program is free software; you can redistribute it and/or */
/* modify it under the terms of the GNU General Public License */
/* as published by the Free Software Foundation; either version 2 */
/* of the License, or (at your option) any later version. */
/* */
/* This program is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
/* GNU General Public License for more details. */
/* */
/* You should have received a copy of the GNU General Public License */
/* along with this program; if not, write to the Free Software */
/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/* */
/* Based on PureData by Miller Puckette and others. */
/* */
/* ---------------------------------------------------------------------------- */
#ifdef PD_0_37
#include "m_pd.h"
#include "s_stuff.h"
#endif
#include "m_imp.h"
#include <sys/types.h>
#include <stdarg.h>
#include <signal.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>
#include <stdio.h>
#ifdef UNIX
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/time.h>
#define SOCKET_ERROR -1
#else
#include <io.h>
#include <fcntl.h>
#include <winsock.h>
#endif
#define MAX_CONNECT 32 /* maximum number of connections */
#define INBUFSIZE 4096 /* size of receiving data buffer */
static char *version = "netrec v0.1, written by Olaf Matthes <olaf.matthes(a)gmx.de>";
/* ----------------------------- netrec ------------------------- */
static t_class *netrec_class;
static t_binbuf *inbinbuf;
typedef void (*t_netrec_socketnotifier)(void *x);
typedef void (*t_netrec_socketreceivefn)(void *x, t_binbuf *b);
typedef struct _netrec
{
t_object x_obj;
t_outlet *x_msgout;
t_outlet *x_connectout;
t_outlet *x_clientno;
t_outlet *x_connectionip;
t_symbol *x_host[MAX_CONNECT];
t_int x_fd[MAX_CONNECT];
t_int x_sock_fd;
int x_connectsocket;
int x_nconnections;
int x_udp;
} t_netrec;
typedef struct _netrec_socketreceiver
{
char *sr_inbuf;
int sr_inhead;
int sr_intail;
void *sr_owner;
int sr_udp;
t_netrec_socketnotifier sr_notifier;
t_netrec_socketreceivefn sr_socketreceivefn;
} t_netrec_socketreceiver;
static t_netrec_socketreceiver *netrec_socketreceiver_new(void *owner, t_netrec_socketnotifier notifier,
t_netrec_socketreceivefn socketreceivefn, int udp)
{
t_netrec_socketreceiver *x = (t_netrec_socketreceiver *)getbytes(sizeof(*x));
x->sr_inhead = x->sr_intail = 0;
x->sr_owner = owner;
x->sr_notifier = notifier;
x->sr_socketreceivefn = socketreceivefn;
x->sr_udp = udp;
if (!(x->sr_inbuf = malloc(INBUFSIZE))) bug("t_netrec_socketreceiver");
return (x);
}
/* this is in a separately called subroutine so that the buffer isn't
sitting on the stack while the messages are getting passed. */
static int netrec_socketreceiver_doread(t_netrec_socketreceiver *x)
{
char messbuf[INBUFSIZE], *bp = messbuf;
int indx;
int inhead = x->sr_inhead;
int intail = x->sr_intail;
char *inbuf = x->sr_inbuf;
if (intail == inhead) return (0);
for (indx = intail; indx != inhead; indx = (indx+1)&(INBUFSIZE-1))
{
char c = *bp++ = inbuf[indx];
if (c == ';' && (!indx || inbuf[indx-1] != '\\'))
{
intail = (indx+1)&(INBUFSIZE-1);
binbuf_text(inbinbuf, messbuf, bp - messbuf);
x->sr_inhead = inhead;
x->sr_intail = intail;
return (1);
}
}
return (0);
}
static void netrec_socketreceiver_getudp(t_netrec_socketreceiver *x, int fd)
{
char buf[INBUFSIZE+1];
int ret = recv(fd, buf, INBUFSIZE, 0);
if (ret < 0)
{
sys_sockerror("recv");
sys_rmpollfn(fd);
sys_closesocket(fd);
}
else if (ret > 0)
{
buf[ret] = 0;
#if 0
post("%s", buf);
#endif
if (buf[ret-1] != '\n')
{
#if 0
buf[ret] = 0;
error("dropped bad buffer %s\n", buf);
#endif
}
else
{
char *semi = strchr(buf, ';');
if (semi)
*semi = 0;
binbuf_text(inbinbuf, buf, strlen(buf));
outlet_setstacklim();
if (x->sr_socketreceivefn)
(*x->sr_socketreceivefn)(x->sr_owner, inbinbuf);
else bug("netrec_socketreceiver_getudp");
}
}
}
static void netrec_socketreceiver_read(t_netrec_socketreceiver *x, int fd)
{
if (x->sr_udp) /* UDP ("datagram") socket protocol */
netrec_socketreceiver_getudp(x, fd);
else /* TCP ("streaming") socket protocol */
{
char *semi;
int readto =
(x->sr_inhead >= x->sr_intail ? INBUFSIZE : x->sr_intail-1);
int ret;
t_netrec *y = x->sr_owner;
y->x_sock_fd = fd;
/* the input buffer might be full. If so, drop the whole thing */
if (readto == x->sr_inhead)
{
fprintf(stderr, "netrec: dropped message");
x->sr_inhead = x->sr_intail = 0;
readto = INBUFSIZE;
}
else
{
ret = recv(fd, x->sr_inbuf + x->sr_inhead,
readto - x->sr_inhead, 0);
if (ret < 0)
{
sys_sockerror("recv");
if (x->sr_notifier) (*x->sr_notifier)(x->sr_owner);
sys_rmpollfn(fd);
sys_closesocket(fd);
}
else if (ret == 0)
{
post("netrec: connection closed on socket %d", fd);
if (x->sr_notifier) (*x->sr_notifier)(x->sr_owner);
sys_rmpollfn(fd);
sys_closesocket(fd);
}
else
{
x->sr_inhead += ret;
if (x->sr_inhead >= INBUFSIZE) x->sr_inhead = 0;
while (netrec_socketreceiver_doread(x))
{
outlet_setstacklim();
if (x->sr_socketreceivefn)
(*x->sr_socketreceivefn)(x->sr_owner, inbinbuf);
else binbuf_eval(inbinbuf, 0, 0, 0);
}
}
}
}
}
static void netrec_socketreceiver_free(t_netrec_socketreceiver *x)
{
free(x->sr_inbuf);
freebytes(x, sizeof(*x));
}
/* ---------------- main netrec stuff --------------------- */
static void netrec_notify(t_netrec *x)
{
int i, k;
/* remove connection from list */
for(i = 0; i < x->x_nconnections; i++)
{
if(x->x_fd[i] == x->x_sock_fd)
{
x->x_nconnections--;
post("netrec: \"%s\" removed from list of clients", x->x_host[i]->s_name);
x->x_host[i] = NULL; /* delete entry */
x->x_fd[i] = -1;
/* rearrange list now: move entries to close the gap */
for(k = i; k < x->x_nconnections; k++)
{
x->x_host[k] = x->x_host[k + 1];
x->x_fd[k] = x->x_fd[k + 1];
}
}
}
outlet_float(x->x_connectout, x->x_nconnections);
}
static void netrec_doit(void *z, t_binbuf *b)
{
t_atom messbuf[1024];
t_netrec *x = (t_netrec *)z;
int msg, natom = binbuf_getnatom(b);
t_atom *at = binbuf_getvec(b);
int i;
/* output clients IP and socket no */
for(i = 0; i < x->x_nconnections; i++)
{
if(x->x_fd[i] == x->x_sock_fd)
{
outlet_symbol(x->x_connectionip, x->x_host[i]);
break;
}
}
outlet_float(x->x_clientno, x->x_sock_fd);
/* process data */
for (msg = 0; msg < natom;)
{
int emsg;
for (emsg = msg; emsg < natom && at[emsg].a_type != A_COMMA
&& at[emsg].a_type != A_SEMI; emsg++);
if (emsg > msg)
{
int ii;
for (ii = msg; ii < emsg; ii++)
if (at[ii].a_type == A_DOLLAR || at[ii].a_type == A_DOLLSYM)
{
pd_error(x, "netrec: got dollar sign in message");
goto nodice;
}
if (at[msg].a_type == A_FLOAT)
{
if (emsg > msg + 1)
outlet_list(x->x_msgout, 0, emsg-msg, at + msg);
else outlet_float(x->x_msgout, at[msg].a_w.w_float);
}
else if (at[msg].a_type == A_SYMBOL)
outlet_anything(x->x_msgout, at[msg].a_w.w_symbol,
emsg-msg-1, at + msg + 1);
}
nodice:
msg = emsg + 1;
}
}
static void netrec_connectpoll(t_netrec *x)
{
struct sockaddr_in incomer_address;
int sockaddrl = (int) sizeof( struct sockaddr );
int fd = accept(x->x_connectsocket, (struct sockaddr*)&incomer_address, &sockaddrl);
if (fd < 0) post("netrec: accept failed");
else
{
t_netrec_socketreceiver *y = netrec_socketreceiver_new((void *)x,
(t_netrec_socketnotifier)netrec_notify,
(x->x_msgout ? netrec_doit : 0), 0);
sys_addpollfn(fd, (t_fdpollfn)netrec_socketreceiver_read, y);
x->x_nconnections++;
x->x_host[x->x_nconnections - 1] = gensym(inet_ntoa(incomer_address.sin_addr));
x->x_fd[x->x_nconnections - 1] = fd;
// outlet_symbol( x->x_connectionip, x->x_host[x->x_nconnections - 1]);
post("netrec: accepted connection from %s on socket %d",
x->x_host[x->x_nconnections - 1]->s_name, x->x_fd[x->x_nconnections - 1]);
outlet_float(x->x_connectout, x->x_nconnections);
}
}
static void netrec_print(t_netrec *x)
{
int i;
if(x->x_nconnections > 0)
{
post("netrec: %d open connections:", x->x_nconnections);
for(i = 0; i < x->x_nconnections; i++)
{
post(" \"%s\" on socket %d",
x->x_host[i]->s_name, x->x_fd[i]);
}
} else post("netrec: no open connections");
}
static void *netrec_new(t_symbol *compatflag,
t_floatarg fportno, t_floatarg udpflag)
{
t_netrec *x;
int i;
struct sockaddr_in server;
int sockfd, portno = fportno, udp = (udpflag != 0);
int old = !strcmp(compatflag->s_name , "old");
/* create a socket */
sockfd = socket(AF_INET, (udp ? SOCK_DGRAM : SOCK_STREAM), 0);
#if 1
post("netrec: receive socket %d\n", sockfd);
#endif
if (sockfd < 0)
{
sys_sockerror("socket");
return (0);
}
server.sin_family = AF_INET;
server.sin_addr.s_addr = INADDR_ANY;
#ifdef IRIX
/* this seems to work only in IRIX but is unnecessary in
Linux. Not sure what NT needs in place of this. */
if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, 0, 0) < 0)
post("setsockopt failed\n");
#endif
/* assign server port number */
server.sin_port = htons((u_short)portno);
/* name the socket */
if (bind(sockfd, (struct sockaddr *)&server, sizeof(server)) < 0)
{
sys_sockerror("bind");
sys_closesocket(sockfd);
return (0);
}
x = (t_netrec *)pd_new(netrec_class);
if (old)
{
/* old style, nonsecure version */
x->x_msgout = 0;
}
else x->x_msgout = outlet_new(&x->x_obj, &s_anything);
if (udp) /* datagram protocol */
{
t_netrec_socketreceiver *y = netrec_socketreceiver_new((void *)x,
(t_netrec_socketnotifier)netrec_notify,
(x->x_msgout ? netrec_doit : 0), 1);
sys_addpollfn(sockfd, (t_fdpollfn)netrec_socketreceiver_read, y);
x->x_connectout = 0;
}
else /* streaming protocol */
{
if (listen(sockfd, 5) < 0)
{
sys_sockerror("listen");
sys_closesocket(sockfd);
sockfd = -1;
}
else
{
sys_addpollfn(sockfd, (t_fdpollfn)netrec_connectpoll, x);
x->x_connectout = outlet_new(&x->x_obj, &s_float);
x->x_clientno = outlet_new(&x->x_obj, &s_float);
x->x_connectionip = outlet_new(&x->x_obj, &s_symbol);
inbinbuf = binbuf_new();
}
}
x->x_connectsocket = sockfd;
x->x_nconnections = 0;
x->x_udp = udp;
for(i = 0; i < MAX_CONNECT; i++)x->x_fd[i] = -1;
return (x);
}
static void netrec_free(t_netrec *x)
{
/* LATER make me clean up open connections */
if (x->x_connectsocket >= 0)
{
sys_rmpollfn(x->x_connectsocket);
sys_closesocket(x->x_connectsocket);
}
binbuf_free(inbinbuf);
}
#ifndef MAXLIB
void netrec_setup(void)
{
netrec_class = class_new(gensym("netrec"),(t_newmethod)netrec_new, (t_method)netrec_free,
sizeof(t_netrec), 0, A_DEFFLOAT, A_DEFFLOAT, A_DEFSYM, 0);
class_addmethod(netrec_class, (t_method)netrec_print, gensym("print"), 0);
class_sethelpsymbol(netrec_class, gensym("help-netrec.pd"));
post(version);
}
#else
void maxlib_netrec_setup(void)
{
netrec_class = class_new(gensym("maxlib_netrec"),(t_newmethod)netrec_new, (t_method)netrec_free,
sizeof(t_netrec), 0, A_DEFFLOAT, A_DEFFLOAT, A_DEFSYM, 0);
class_addcreator((t_newmethod)netrec_new, gensym("netrec"), A_DEFFLOAT, A_DEFFLOAT, A_DEFSYM, 0);
class_addmethod(netrec_class, (t_method)netrec_print, gensym("print"), 0);
class_sethelpsymbol(netrec_class, gensym("maxlib/help-netrec.pd"));
}
#endif
--- NEW FILE: bilex.c ---
/* ---------------------------- rand_bilex ------------------------------------ */
/* */
/* rand_bilex generates a bilinear exponentially distributed random variable. */
/* Written by Olaf Matthes (olaf.matthes(a)gmx.de) */
/* Based on code found in Dodge/Jerse "Computer Music" */
/* Get source at http://www.akustische-kunst.org/puredata/maxlib/ */
/* */
/* This program is free software; you can redistribute it and/or */
/* modify it under the terms of the GNU General Public License */
/* as published by the Free Software Foundation; either version 2 */
/* of the License, or (at your option) any later version. */
/* */
/* This program is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
/* GNU General Public License for more details. */
/* */
/* You should have received a copy of the GNU General Public License */
/* along with this program; if not, write to the Free Software */
/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/* */
/* Based on PureData by Miller Puckette and others. */
/* */
/* ---------------------------------------------------------------------------- */
#include "m_pd.h"
#include <stdlib.h>
#include <time.h>
#include <math.h>
#define fran() (t_float)rand()/(t_float)RAND_MAX
static char *version = "bilex v0.1, generates bilinear exponentially distributed random\n"
" variable, written by Olaf Matthes <olaf.matthes(a)gmx.de>";
/* -------------------------- rand_bilex ------------------------------ */
static t_class *rand_bilex_class;
typedef struct _rand_bilex
{
t_object x_obj;
t_float x_lambda;
} t_rand_bilex;
static void *rand_bilex_new(t_floatarg f)
{
t_rand_bilex *x = (t_rand_bilex *)pd_new(rand_bilex_class);
srand( (unsigned)time( NULL ) );
floatinlet_new(&x->x_obj, &x->x_lambda);
outlet_new(&x->x_obj, &s_float);
x->x_lambda = f;
return (x);
}
static void rand_bilex_bang(t_rand_bilex *x)
{
t_float u, s = 1, l;
l = (x->x_lambda <= 0 ? 0.0001 : x->x_lambda);
do
{
u = 2*fran();
}
while(u == 0 || u == 2);
if(u > 1)
{
u = 2-u;
s=-1;
}
outlet_float(x->x_obj.ob_outlet, s*log(u)/l);
}
#ifndef MAXLIB
void bilex_setup(void)
{
rand_bilex_class = class_new(gensym("bilex"), (t_newmethod)rand_bilex_new, 0,
sizeof(t_rand_bilex), 0, A_DEFFLOAT, 0);
class_addbang(rand_bilex_class, rand_bilex_bang);
class_sethelpsymbol(rand_bilex_class, gensym("help-bilex.pd"));
post(version);
}
#else
void maxlib_bilex_setup(void)
{
rand_bilex_class = class_new(gensym("maxlib_bilex"), (t_newmethod)rand_bilex_new, 0,
sizeof(t_rand_bilex), 0, A_DEFFLOAT, 0);
class_addbang(rand_bilex_class, rand_bilex_bang);
class_addcreator((t_newmethod)rand_bilex_new, gensym("bilex"), A_DEFFLOAT, 0);
class_sethelpsymbol(rand_bilex_class, gensym("maxlib/help-bilex.pd"));
}
#endif
--- NEW FILE: expo.c ---
/* ---------------------------- rand_expo ------------------------------------- */
/* */
/* rand_expo generates a exponentially distributed random variable. */
/* Written by Olaf Matthes (olaf.matthes(a)gmx.de) */
/* Based on code found in Dodge/Jerse "Computer Music" */
/* Get source at http://www.akustische-kunst.org/puredata/maxlib/ */
/* */
/* This program is free software; you can redistribute it and/or */
/* modify it under the terms of the GNU General Public License */
/* as published by the Free Software Foundation; either version 2 */
/* of the License, or (at your option) any later version. */
/* */
/* This program is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
/* GNU General Public License for more details. */
/* */
/* You should have received a copy of the GNU General Public License */
/* along with this program; if not, write to the Free Software */
/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/* */
/* Based on PureData by Miller Puckette and others. */
/* */
/* ---------------------------------------------------------------------------- */
#include "m_pd.h"
#include <stdlib.h>
#include <time.h>
#include <math.h>
#define fran() (t_float)rand()/(t_float)RAND_MAX
static char *version = "expo v0.1, generates exponentially distributed random variable\n"
" written by Olaf Matthes <olaf.matthes(a)gmx.de>";
/* -------------------------- rand_expo ------------------------------ */
static t_class *rand_expo_class;
typedef struct _rand_expo
{
t_object x_obj;
t_float x_lambda;
} t_rand_expo;
static void *rand_expo_new(t_floatarg f)
{
t_rand_expo *x = (t_rand_expo *)pd_new(rand_expo_class);
srand( (unsigned)time( NULL ) );
floatinlet_new(&x->x_obj, &x->x_lambda);
outlet_new(&x->x_obj, &s_float);
x->x_lambda = f;
return (x);
}
static void rand_expo_bang(t_rand_expo *x)
{
t_float u, l;
l = (x->x_lambda <= 0 ? 0.0001 : x->x_lambda);
do
{
u = fran();
}
while(u == 0);
outlet_float(x->x_obj.ob_outlet, -log(u)/l);
}
#ifndef MAXLIB
void expo_setup(void)
{
rand_expo_class = class_new(gensym("expo"), (t_newmethod)rand_expo_new, 0,
sizeof(t_rand_expo), 0, A_DEFFLOAT, 0);
class_addbang(rand_expo_class, rand_expo_bang);
class_sethelpsymbol(rand_expo_class, gensym("help-expo.pd"));
post(version);
}
#else
void maxlib_expo_setup(void)
{
rand_expo_class = class_new(gensym("maxlib_expo"), (t_newmethod)rand_expo_new, 0,
sizeof(t_rand_expo), 0, A_DEFFLOAT, 0);
class_addbang(rand_expo_class, rand_expo_bang);
class_addcreator((t_newmethod)rand_expo_new, gensym("expo"), A_DEFFLOAT, 0);
class_sethelpsymbol(rand_expo_class, gensym("maxlib/help-expo.pd"));
}
#endif
--- NEW FILE: poisson.c ---
/* ---------------------------- rand_poisson ---------------------------------- */
/* */
/* rand_poisson generates a poisson distributed random variable. */
/* Written by Olaf Matthes (olaf.matthes(a)gmx.de) */
/* Based on code found in Dodge/Jerse "Computer Music" */
/* Get source at http://www.akustische-kunst.org/puredata/maxlib/ */
/* */
/* This program is free software; you can redistribute it and/or */
/* modify it under the terms of the GNU General Public License */
/* as published by the Free Software Foundation; either version 2 */
/* of the License, or (at your option) any later version. */
/* */
/* This program is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
/* GNU General Public License for more details. */
/* */
/* You should have received a copy of the GNU General Public License */
/* along with this program; if not, write to the Free Software */
/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/* */
/* Based on PureData by Miller Puckette and others. */
/* */
/* ---------------------------------------------------------------------------- */
#include "m_pd.h"
#include <stdlib.h>
#include <time.h>
#include <math.h>
#define fran() (t_float)rand()/(t_float)RAND_MAX
#ifndef M_PI
#define M_PI 3.1415927
#endif
static char *version = "poisson v0.1, generates a poisson distributed random variable\n"
" written by Olaf Matthes <olaf.matthes(a)gmx.de>";
/* -------------------------- rand_poisson ------------------------------ */
static t_class *rand_poisson_class;
typedef struct _rand_poisson
{
t_object x_obj;
t_float x_lambda;
} t_rand_poisson;
static void *rand_poisson_new(t_floatarg f)
{
t_rand_poisson *x = (t_rand_poisson *)pd_new(rand_poisson_class);
srand( (unsigned)time( NULL ) );
floatinlet_new(&x->x_obj, &x->x_lambda);
outlet_new(&x->x_obj, &s_float);
x->x_lambda = f;
return (x);
}
static void rand_poisson_bang(t_rand_poisson *x)
{
t_float u, v;
t_int n = 0;
v = exp(-x->x_lambda);
u = fran();
while(u > v)
{
u *= fran();
n++;
}
outlet_float(x->x_obj.ob_outlet, n);
}
#ifndef MAXLIB
void poisson_setup(void)
{
rand_poisson_class = class_new(gensym("poisson"), (t_newmethod)rand_poisson_new, 0,
sizeof(t_rand_poisson), 0, A_DEFFLOAT, 0);
class_addbang(rand_poisson_class, rand_poisson_bang);
class_sethelpsymbol(rand_poisson_class, gensym("help-poisson.pd"));
post(version);
}
#else
void maxlib_poisson_setup(void)
{
rand_poisson_class = class_new(gensym("maxlib_poisson"), (t_newmethod)rand_poisson_new, 0,
sizeof(t_rand_poisson), 0, A_DEFFLOAT, 0);
class_addcreator((t_newmethod)rand_poisson_new, gensym("poisson"), A_DEFFLOAT, 0);
class_addbang(rand_poisson_class, rand_poisson_bang);
class_sethelpsymbol(rand_poisson_class, gensym("maxlib/help-poisson.pd"));
}
#endif
--- NEW FILE: tilt.c ---
/* ------------------------- tilt --------------------------------------------- */
/* */
/* Monitor input for changes. */
/* Written by Olaf Matthes (olaf.matthes(a)gmx.de) */
/* Inspired by code written by Trond Lossius. */
/* Get source at http://www.akustische-kunst.org/puredata/maxlib/ */
/* */
/* This program is free software; you can redistribute it and/or */
/* modify it under the terms of the GNU General Public License */
/* as published by the Free Software Foundation; either version 2 */
/* of the License, or (at your option) any later version. */
/* */
/* This program is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
/* GNU General Public License for more details. */
/* */
/* You should have received a copy of the GNU General Public License */
/* along with this program; if not, write to the Free Software */
/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/* */
/* Based on PureData by Miller Puckette and others. */
/* */
/* ---------------------------------------------------------------------------- */
#include "m_pd.h"
#include <stdio.h>
#include <stdlib.h>
#define MAXSIZE 32
static char *version = "tilt v0.1, written by Olaf Matthes <olaf.matthes(a)gmx.de>";
typedef struct tilt
{
t_object x_ob;
t_outlet *x_out; /* result */
t_clock *x_clock;
t_float x_tilt; /* the result */
t_float x_start_tilt;
t_float x_t;
t_float x_sa;
t_float x_sb;
t_float x_offset;
t_float x_time;
t_float x_wait;
t_float x_hi_limit;
t_float x_low_limit;
t_float x_trip_point;
} t_tilt;
static void tilt_tick(t_tilt *x)
{
x->x_sb = x->x_t - x->x_offset;
if((x->x_sb - x->x_sa) > x->x_hi_limit)
{
x->x_sa = x->x_sb;
clock_delay(x->x_clock, x->x_wait);
return;
}
else
{
if((x->x_sb - x->x_sa) > x->x_trip_point)
{
outlet_bang(x->x_out);
clock_delay(x->x_clock, x->x_wait);
return;
}
if((x->x_sb - x->x_sa) < x->x_low_limit)
{
x->x_time++;
if(x->x_time > 15)
{
x->x_start_tilt = x->x_sa;
x->x_time = 0;
}
}
if((x->x_sb - x->x_start_tilt) > x->x_tilt)
{
outlet_bang(x->x_out);
clock_delay(x->x_clock, x->x_wait);
}
else
{
x->x_sa = x->x_sb;
clock_delay(x->x_clock, x->x_wait);
return;
}
}
}
static void tilt_float(t_tilt *x, t_floatarg f)
{
x->x_t = f;
}
static void tilt_intv(t_tilt *x, t_floatarg f)
{
x->x_wait = f;
}
static void tilt_tilt(t_tilt *x, t_floatarg f)
{
x->x_tilt = f;
post("tilt: set tilt to %g", x->x_tilt);
}
static void tilt_hi_limit(t_tilt *x, t_floatarg f)
{
x->x_hi_limit = f;
post("tilt: set high limit to %g", x->x_hi_limit);
}
static void tilt_low_limit(t_tilt *x, t_floatarg f)
{
x->x_low_limit = f;
post("tilt: set low limit to %g", x->x_low_limit);
}
static void tilt_trip_point(t_tilt *x, t_floatarg f)
{
x->x_trip_point = f;
post("tilt: set trip point to %g", x->x_trip_point);
}
static void tilt_free(t_tilt *x)
{
clock_free(x->x_clock);
}
static t_class *tilt_class;
static void *tilt_new(t_floatarg f, t_floatarg f2)
{
int i;
t_tilt *x = (t_tilt *)pd_new(tilt_class);
inlet_new(&x->x_ob, &x->x_ob.ob_pd, gensym("float"), gensym("intv"));
x->x_out = outlet_new(&x->x_ob, gensym("float"));
x->x_clock = clock_new(x, (t_method)tilt_tick);
x->x_t = f; /* set initial value */
if(f2 > 4)
x->x_wait = f2;
else
x->x_wait = 4000;
x->x_offset = 0;
x->x_sa = 0;
x->x_sb = 0;
x->x_time = 0;
x->x_tilt = 0;
x->x_start_tilt = x->x_sa = x->x_t - x->x_offset;
x->x_hi_limit = x->x_low_limit = x->x_trip_point = 0;
clock_delay(x->x_clock, x->x_wait); /* wait 4 sec and start calculation */
post("tilt: set interval to %g msec", x->x_wait);
return (void *)x;
}
#ifndef MAXLIB
void tilt_setup(void)
{
tilt_class = class_new(gensym("tilt"), (t_newmethod)tilt_new,
(t_method)tilt_free, sizeof(t_tilt), 0, A_DEFFLOAT, A_DEFFLOAT, 0);
class_addfloat(tilt_class, tilt_float);
class_addmethod(tilt_class, (t_method)tilt_intv, gensym("intv"), A_FLOAT, 0);
class_addmethod(tilt_class, (t_method)tilt_tilt, gensym("tilt"), A_FLOAT, 0);
class_addmethod(tilt_class, (t_method)tilt_hi_limit, gensym("hi"), A_FLOAT, 0);
class_addmethod(tilt_class, (t_method)tilt_low_limit, gensym("low"), A_FLOAT, 0);
class_addmethod(tilt_class, (t_method)tilt_trip_point, gensym("trip"), A_FLOAT, 0);
class_sethelpsymbol(tilt_class, gensym("help-tilt.pd"));
post(version);
}
#else
void maxlib_tilt_setup(void)
{
tilt_class = class_new(gensym("maxlib_tilt"), (t_newmethod)tilt_new,
(t_method)tilt_free, sizeof(t_tilt), 0, A_DEFFLOAT, A_DEFFLOAT, 0);
class_addcreator((t_newmethod)tilt_new, gensym("tilt"), A_DEFFLOAT, A_DEFFLOAT, 0);
class_addfloat(tilt_class, tilt_float);
class_addmethod(tilt_class, (t_method)tilt_intv, gensym("intv"), A_FLOAT, 0);
class_addmethod(tilt_class, (t_method)tilt_tilt, gensym("tilt"), A_FLOAT, 0);
class_addmethod(tilt_class, (t_method)tilt_hi_limit, gensym("hi"), A_FLOAT, 0);
class_addmethod(tilt_class, (t_method)tilt_low_limit, gensym("low"), A_FLOAT, 0);
class_addmethod(tilt_class, (t_method)tilt_trip_point, gensym("trip"), A_FLOAT, 0);
class_sethelpsymbol(tilt_class, gensym("maxlib/help-tilt.pd"));
}
#endif
--- NEW FILE: plus.c ---
/* --------------------------- plus ------------------------------------------ */
/* */
/* Like '+', but calculates output whenever _any_ of the inlets changes. */
/* Written by Olaf Matthes (olaf.matthes(a)gmx.de) */
/* Get source at http://www.akustische-kunst.org/puredata/maxlib/ */
/* */
/* This program is free software; you can redistribute it and/or */
/* modify it under the terms of the GNU General Public License */
/* as published by the Free Software Foundation; either version 2 */
/* of the License, or (at your option) any later version. */
/* */
/* This program is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
/* GNU General Public License for more details. */
/* */
/* You should have received a copy of the GNU General Public License */
/* along with this program; if not, write to the Free Software */
/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/* */
/* Based on PureData by Miller Puckette and others. */
/* */
/* ---------------------------------------------------------------------------- */
#include "m_pd.h"
#include <stdio.h>
#define MAXSIZE 32
static char *version = "plus v0.2, written by Olaf Matthes <olaf.matthes(a)gmx.de>";
typedef struct plus
{
t_object x_ob;
t_inlet *x_inleft; /* leftmost inlet */
t_inlet *x_inright; /* right inlet */
t_outlet *x_outlet; /* result */
t_int x_numvalues; /* number of values / inlets */
t_float x_plusvalue[MAXSIZE];
} t_plus;
static void plus_bang(t_plus *x)
{
int i;
t_float result = x->x_plusvalue[0];
for(i = 1; i < x->x_numvalues; i++)
result += x->x_plusvalue[i];
outlet_float(x->x_outlet, result);
}
static void plus_float(t_plus *x, t_floatarg f)
{
x->x_plusvalue[0] = f;
plus_bang(x); /* calculate result */
}
static void plus_ft1(t_plus *x, t_floatarg f)
{
x->x_plusvalue[1] = f;
plus_bang(x); /* calculate result */
}
static t_class *plus_class;
static void *plus_new(t_symbol *s, t_int argc, t_atom* argv)
{
int i;
t_plus *x = (t_plus *)pd_new(plus_class);
x->x_inright = inlet_new(&x->x_ob, &x->x_ob.ob_pd, gensym("float"), gensym("ft1"));
for(i = 2; i < argc; i++) /* create additional inlets, if any */
{
floatinlet_new(&x->x_ob, &x->x_plusvalue[i]);
}
x->x_outlet = outlet_new(&x->x_ob, gensym("float"));
for(i = 0; i < argc; i++)
{
x->x_plusvalue[i] = atom_getfloatarg(i, argc, argv);;
}
x->x_numvalues = i;
return (void *)x;
}
#ifndef MAXLIB
void plus_setup(void)
{
plus_class = class_new(gensym("plus"), (t_newmethod)plus_new,
0, sizeof(t_plus), 0, A_GIMME, 0);
class_addfloat(plus_class, plus_float);
class_addmethod(plus_class, (t_method)plus_ft1, gensym("ft1"), A_FLOAT, 0);
class_addbang(plus_class, (t_method)plus_bang);
class_sethelpsymbol(plus_class, gensym("help-plus.pd"));
post(version);
}
#else
void maxlib_plus_setup(void)
{
plus_class = class_new(gensym("maxlib_plus"), (t_newmethod)plus_new,
0, sizeof(t_plus), 0, A_GIMME, 0);
class_addcreator((t_newmethod)plus_new, gensym("plus"), A_GIMME, 0);
class_addfloat(plus_class, plus_float);
class_addmethod(plus_class, (t_method)plus_ft1, gensym("ft1"), A_FLOAT, 0);
class_addbang(plus_class, (t_method)plus_bang);
class_sethelpsymbol(plus_class, gensym("maxlib/help-plus.pd"));
}
#endif
--- NEW FILE: timebang.c ---
/* ------------------------- timebang --------------------------------------- */
/* */
/* Send out bangs at given times (time of day!). */
/* Written by Olaf Matthes <olaf.matthes(a)gmx.de> */
/* Get source at http://www.akustische-kunst.org/puredata/maxlib/ */
/* */
/* This program is free software; you can redistribute it and/or */
/* modify it under the terms of the GNU General Public License */
/* as published by the Free Software Foundation; either version 2 */
/* of the License, or (at your option) any later version. */
/* */
/* This program is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
/* GNU General Public License for more details. */
/* */
/* You should have received a copy of the GNU General Public License */
/* along with this program; if not, write to the Free Software */
/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/* */
/* Based on PureData by Miller Puckette and others. */
/* */
/* ---------------------------------------------------------------------------- */
#include "m_pd.h"
#include <stdio.h>
#include <math.h>
#include <time.h>
#define MAX_TIMES 256 /* maximum number of times to process */
static char *version = "timebang v0.2, written by Olaf Matthes <olaf.matthes(a)gmx.de>";
typedef struct timebang
{
t_object x_ob;
t_clock *x_clock;
t_outlet *x_outlet[MAX_TIMES]; /* the bang outlets */
t_int x_sec[MAX_TIMES]; /* seconds (0 - 59) */
t_int x_min[MAX_TIMES]; /* minutes (0 - 59) */
t_int x_hour[MAX_TIMES]; /* hours (0 - 11) */
t_int x_mday[MAX_TIMES]; /* day of month (1 - 31) */
t_int x_mon[MAX_TIMES]; /* month (0 - 11) */
t_int x_year[MAX_TIMES]; /* year (current year minus 1900) */
t_int x_wday[MAX_TIMES]; /* day of week (0 - 6, Sunday = 0, -1 = all days) */
t_int x_over[MAX_TIMES]; /* indicate that time is over */
t_int x_notimes; /* number of times to bang */
} t_timebang;
static void timebang_tick(t_timebang *x)
{
time_t now = time(NULL);
struct tm *newtime;
int i;
newtime = localtime(&now); /* convert to local time. */
for(i = 0; i < x->x_notimes; i++)
{
if(!x->x_over[i])
{
if(newtime->tm_hour == x->x_hour[i] &&
newtime->tm_min == x->x_min[i] &&
newtime->tm_sec >= x->x_sec[i])
{
x->x_over[i] = 1; /* mark as 'time is over' */
outlet_bang(x->x_outlet[i]); /* send corresponding bang */
}
}
else if(newtime->tm_hour != x->x_hour[i])
x->x_over[i] = 0; /* reactivate time one hour later */
}
clock_delay(x->x_clock, 1000); /* come back in one second */
}
static void timebang_set(t_timebang *x, t_symbol *s, int ac, t_atom *av)
{
int i;
if(ac == x->x_notimes * 3)
{
for(i = 0; i < ac; i += 3)
{
if (av[i].a_type == A_FLOAT) x->x_hour[x->x_notimes] = av[i].a_w.w_float;
else { post ("timebang: first argument must be (int) hours"); return; }
if (av[i+1].a_type == A_FLOAT) x->x_min[x->x_notimes] = av[i+1].a_w.w_float;
else { post ("timebang: second argument must be (int) minutes"); return; }
if (av[i+2].a_type == A_FLOAT) x->x_sec[x->x_notimes] = av[i+2].a_w.w_float;
else { post ("timebang: third argument must be (int) seconds"); return; }
x->x_over[i] = 0;
}
post("timebang: read in %d times of day:", x->x_notimes);
for(i = 0; i < x->x_notimes; i++)
{
post(" %02d:%02d:%02d", x->x_hour[i], x->x_min[i], x->x_sec[i]);
}
}
else post("timebang: wrong number of parameter");
}
static void timebang_bang(t_timebang *x)
{
time_t now = time(NULL);
struct tm *newtime = localtime(&now); /* convert to local time. */
post("timebang: local time is %02d:%02d:%02d", newtime->tm_hour, newtime->tm_min, newtime->tm_sec);
}
static t_class *timebang_class;
static void *timebang_new(t_symbol *s, int ac, t_atom *av)
{
int i;
t_timebang *x = (t_timebang *)pd_new(timebang_class);
x->x_clock = clock_new(x, (t_method)timebang_tick);
if(ac > MAX_TIMES * 3)
{
post("timebang: too many creation arguments");
ac = MAX_TIMES * 3;
}
x->x_notimes = 0;
for(i = 0; i < ac; i += 3)
{
if (av[i].a_type == A_FLOAT) x->x_hour[x->x_notimes] = av[i].a_w.w_float;
else { post ("timebang: first argument must be (int) hours"); return 0; }
if (av[i+1].a_type == A_FLOAT) x->x_min[x->x_notimes] = av[i+1].a_w.w_float;
else { post ("timebang: second argument must be (int) minutes"); return 0; }
if (av[i+2].a_type == A_FLOAT) x->x_sec[x->x_notimes] = av[i+2].a_w.w_float;
else { post ("timebang: third argument must be (int) seconds"); return 0; }
x->x_over[x->x_notimes] = 0;
x->x_notimes++;
}
post("timebang: read in %d times of day:", x->x_notimes);
for(i = 0; i < x->x_notimes; i++)
{
x->x_outlet[i] = outlet_new(&x->x_ob, gensym("bang")); /* create specific bang outlet for time */
post(" %02d:%02d:%02d", x->x_hour[i], x->x_min[i], x->x_sec[i]);
}
clock_set(x->x_clock, 0);
return (void *)x;
}
static void timebang_free(t_timebang *x)
{
clock_free(x->x_clock);
}
#ifndef MAXLIB
void timebang_setup(void)
{
timebang_class = class_new(gensym("timebang"), (t_newmethod)timebang_new,
(t_method)timebang_free, sizeof(t_timebang), 0, A_GIMME, 0);
#else
void maxlib_timebang_setup(void)
{
timebang_class = class_new(gensym("maxlib_timebang"), (t_newmethod)timebang_new,
(t_method)timebang_free, sizeof(t_timebang), 0, A_GIMME, 0);
class_addcreator((t_newmethod)timebang_new, gensym("timebang"), A_GIMME, 0);
#endif
class_addmethod(timebang_class, (t_method)timebang_set, gensym("set"), A_GIMME, 0);
class_addbang(timebang_class, (t_method)timebang_bang);
#ifndef MAXLIB
class_sethelpsymbol(timebang_class, gensym("help-timebang.pd"));
post(version);
#else
class_sethelpsymbol(timebang_class, gensym("maxlib/help-timebang.pd"));
#endif
}
--- NEW FILE: netserver.c ---
/* -------------------------- netserver ------------------------------------- */
/* */
/* A server for bidirectional communication from within Pd. */
/* Allows to send back data to specific clients connected to the server. */
/* Written by Olaf Matthes <olaf.matthes(a)gmx.de> */
/* Get source at http://www.akustische-kunst.org/puredata/maxlib */
/* */
/* This program is free software; you can redistribute it and/or */
/* modify it under the terms of the GNU General Public License */
/* as published by the Free Software Foundation; either version 2 */
/* of the License, or (at your option) any later version. */
/* */
/* This program is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
/* GNU General Public License for more details. */
/* */
/* You should have received a copy of the GNU General Public License */
/* along with this program; if not, write to the Free Software */
/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/* */
/* Based on PureData by Miller Puckette and others. */
/* */
/* ---------------------------------------------------------------------------- */
#ifdef PD_0_37
#include "m_pd.h"
#include "s_stuff.h"
#endif
#include "m_imp.h"
#include <sys/types.h>
#include <stdarg.h>
#include <signal.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>
#include <stdio.h>
#include <pthread.h>
#ifdef UNIX
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/time.h>
#define SOCKET_ERROR -1
#else
#include <io.h>
#include <fcntl.h>
#include <winsock.h>
#endif
#define MAX_CONNECT 32 /* maximum number of connections */
#define INBUFSIZE 4096 /* size of receiving data buffer */
static char *version = "netserver v0.2 :: bidirectional communication for Pd\n"
" written by Olaf Matthes <olaf.matthes(a)gmx.de>";
/* ----------------------------- netserver ------------------------- */
static t_class *netserver_class;
static t_binbuf *inbinbuf;
typedef void (*t_netserver_socketnotifier)(void *x);
typedef void (*t_netserver_socketreceivefn)(void *x, t_binbuf *b);
typedef struct _netserver
{
t_object x_obj;
t_outlet *x_msgout;
t_outlet *x_connectout;
t_outlet *x_clientno;
t_outlet *x_connectionip;
t_symbol *x_host[MAX_CONNECT];
t_int x_fd[MAX_CONNECT];
t_int x_sock_fd;
t_int x_connectsocket;
t_int x_nconnections;
} t_netserver;
typedef struct _netserver_socketreceiver
{
char *sr_inbuf;
int sr_inhead;
int sr_intail;
void *sr_owner;
t_netserver_socketnotifier sr_notifier;
t_netserver_socketreceivefn sr_socketreceivefn;
} t_netserver_socketreceiver;
static t_netserver_socketreceiver *netserver_socketreceiver_new(void *owner, t_netserver_socketnotifier notifier,
t_netserver_socketreceivefn socketreceivefn)
{
t_netserver_socketreceiver *x = (t_netserver_socketreceiver *)getbytes(sizeof(*x));
x->sr_inhead = x->sr_intail = 0;
x->sr_owner = owner;
x->sr_notifier = notifier;
x->sr_socketreceivefn = socketreceivefn;
if (!(x->sr_inbuf = malloc(INBUFSIZE))) bug("t_netserver_socketreceiver");
return (x);
}
/* this is in a separately called subroutine so that the buffer isn't
sitting on the stack while the messages are getting passed. */
static int netserver_socketreceiver_doread(t_netserver_socketreceiver *x)
{
char messbuf[INBUFSIZE], *bp = messbuf;
int indx;
int inhead = x->sr_inhead;
int intail = x->sr_intail;
char *inbuf = x->sr_inbuf;
if (intail == inhead) return (0);
for (indx = intail; indx != inhead; indx = (indx+1)&(INBUFSIZE-1))
{
char c = *bp++ = inbuf[indx];
if (c == ';' && (!indx || inbuf[indx-1] != '\\'))
{
intail = (indx+1)&(INBUFSIZE-1);
binbuf_text(inbinbuf, messbuf, bp - messbuf);
x->sr_inhead = inhead;
x->sr_intail = intail;
return (1);
}
}
return (0);
}
static void netserver_socketreceiver_read(t_netserver_socketreceiver *x, int fd)
{
char *semi;
int readto = (x->sr_inhead >= x->sr_intail ? INBUFSIZE : x->sr_intail-1);
int ret;
t_netserver *y = x->sr_owner;
y->x_sock_fd = fd;
/* the input buffer might be full. If so, drop the whole thing */
if (readto == x->sr_inhead)
{
post("netserver: dropped message");
x->sr_inhead = x->sr_intail = 0;
readto = INBUFSIZE;
}
else
{
ret = recv(fd, x->sr_inbuf + x->sr_inhead,
readto - x->sr_inhead, 0);
if (ret < 0)
{
sys_sockerror("recv");
if (x->sr_notifier) (*x->sr_notifier)(x->sr_owner);
sys_rmpollfn(fd);
sys_closesocket(fd);
}
else if (ret == 0)
{
post("netserver: << connection closed on socket %d", fd);
if (x->sr_notifier) (*x->sr_notifier)(x->sr_owner);
sys_rmpollfn(fd);
sys_closesocket(fd);
}
else
{
x->sr_inhead += ret;
if (x->sr_inhead >= INBUFSIZE) x->sr_inhead = 0;
while (netserver_socketreceiver_doread(x))
{
outlet_setstacklim();
if (x->sr_socketreceivefn)
(*x->sr_socketreceivefn)(x->sr_owner, inbinbuf);
else binbuf_eval(inbinbuf, 0, 0, 0);
}
}
}
}
static void netserver_socketreceiver_free(t_netserver_socketreceiver *x)
{
free(x->sr_inbuf);
freebytes(x, sizeof(*x));
}
/* ---------------- main netserver (send) stuff --------------------- */
/* send message to client using socket number */
static void netserver_send(t_netserver *x, t_symbol *s, int argc, t_atom *argv)
{
int sockfd, client = -1, i;
if(x->x_nconnections < 0)
{
post("netserver: no clients connected");
return;
}
if(argc < 2)
{
post("netserver: nothing to send");
return;
}
/* get socket number of connection (first element in list) */
if(argv[0].a_type == A_FLOAT)
{
sockfd = atom_getfloatarg(0, argc, argv);
for(i = 0; i < x->x_nconnections; i++) /* check if connection exists */
{
if(x->x_fd[i] == sockfd)
{
client = i; /* the client we're sending to */
break;
}
}
if(client == -1)
{
post("netserver: no connection on socket %d", sockfd);
return;
}
}
else
{
post("netserver: no socket specified");
return;
}
/* process & send data */
if(sockfd > 0)
{
t_binbuf *b = binbuf_new();
char *buf, *bp;
int length, sent;
t_atom at;
binbuf_add(b, argc - 1, argv + 1); /* skip first element */
SETSEMI(&at);
binbuf_add(b, 1, &at);
binbuf_gettext(b, &buf, &length);
post("netserver: sending data to client %d on socket %d", client + 1, sockfd);
// post("netserver: sending \"%s\"", buf);
for (bp = buf, sent = 0; sent < length;)
{
static double lastwarntime;
static double pleasewarn;
double timebefore = clock_getlogicaltime();
int res = send(sockfd, buf, length-sent, 0);
double timeafter = clock_getlogicaltime();
int late = (timeafter - timebefore > 0.005);
if (late || pleasewarn)
{
if (timeafter > lastwarntime + 2)
{
post("netserver blocked %d msec",
(int)(1000 * ((timeafter - timebefore) + pleasewarn)));
pleasewarn = 0;
lastwarntime = timeafter;
}
else if (late) pleasewarn += timeafter - timebefore;
}
if (res <= 0)
{
sys_sockerror("netserver");
post("netserver: could not send data to client");
break;
}
else
{
sent += res;
bp += res;
}
}
t_freebytes(buf, length);
binbuf_free(b);
}
else post("netserver: not a valid socket number (%d)", sockfd);
}
/* send message to client using client number
note that the client numbers might change in case a client disconnects! */
static void netserver_client_send(t_netserver *x, t_symbol *s, int argc, t_atom *argv)
{
int sockfd, client;
if(x->x_nconnections < 0)
{
post("netserver: no clients connected");
return;
}
if(argc < 2)
{
post("netserver: nothing to send");
return;
}
/* get number of client (first element in list) */
if(argv[0].a_type == A_FLOAT)
client = atom_getfloatarg(0, argc, argv);
else
{
post("netserver: no client specified");
return;
}
sockfd = x->x_fd[client - 1]; /* get socket number for that client */
/* process & send data */
if(sockfd > 0)
{
t_binbuf *b = binbuf_new();
char *buf, *bp;
int length, sent;
t_atom at;
binbuf_add(b, argc - 1, argv + 1); /* skip first element */
SETSEMI(&at);
binbuf_add(b, 1, &at);
binbuf_gettext(b, &buf, &length);
post("netserver: sending data to client %d on socket %d", client, sockfd);
// post("netserver: >> sending \"%s\"", buf);
for (bp = buf, sent = 0; sent < length;)
{
static double lastwarntime;
static double pleasewarn;
double timebefore = clock_getlogicaltime();
int res = send(sockfd, buf, length-sent, 0);
double timeafter = clock_getlogicaltime();
int late = (timeafter - timebefore > 0.005);
if (late || pleasewarn)
{
if (timeafter > lastwarntime + 2)
{
post("netserver blocked %d msec",
(int)(1000 * ((timeafter - timebefore) + pleasewarn)));
pleasewarn = 0;
lastwarntime = timeafter;
}
else if (late) pleasewarn += timeafter - timebefore;
}
if (res <= 0)
{
sys_sockerror("netserver");
post("netserver: could not send data to cient");
break;
}
else
{
sent += res;
bp += res;
}
}
t_freebytes(buf, length);
binbuf_free(b);
}
else post("netserver: not a valid socket number (%d)", sockfd);
}
/* broadcasts a message to all connected clients */
static void netserver_broadcast(t_netserver *x, t_symbol *s, int argc, t_atom *argv)
{
int i, client = x->x_nconnections; /* number of clients to send to */
t_atom at[256];
for(i = 0; i < argc; i++)
{
at[i + 1] = argv[i];
}
argc++;
/* enumerate through the clients and send each the message */
while(client--)
{
SETFLOAT(at, client + 1); /* prepend number of client */
netserver_client_send(x, s, argc, at);
}
}
/* ---------------- main netserver (receive) stuff --------------------- */
static void netserver_notify(t_netserver *x)
{
int i, k;
/* remove connection from list */
for(i = 0; i < x->x_nconnections; i++)
{
if(x->x_fd[i] == x->x_sock_fd)
{
x->x_nconnections--;
post("netserver: \"%s\" removed from list of clients", x->x_host[i]->s_name);
x->x_host[i] = NULL; /* delete entry */
x->x_fd[i] = -1;
/* rearrange list now: move entries to close the gap */
for(k = i; k < x->x_nconnections; k++)
{
x->x_host[k] = x->x_host[k + 1];
x->x_fd[k] = x->x_fd[k + 1];
}
}
}
outlet_float(x->x_connectout, x->x_nconnections);
}
static void netserver_doit(void *z, t_binbuf *b)
{
t_atom messbuf[1024];
t_netserver *x = (t_netserver *)z;
int msg, natom = binbuf_getnatom(b);
t_atom *at = binbuf_getvec(b);
int i;
/* output clients IP and socket no. */
for(i = 0; i < x->x_nconnections; i++) /* search for corresponding IP */
{
if(x->x_fd[i] == x->x_sock_fd)
{
outlet_symbol(x->x_connectionip, x->x_host[i]);
break;
}
}
outlet_float(x->x_clientno, x->x_sock_fd); /* the socket number */
/* process data */
for (msg = 0; msg < natom;)
{
int emsg;
for (emsg = msg; emsg < natom && at[emsg].a_type != A_COMMA
&& at[emsg].a_type != A_SEMI; emsg++);
if (emsg > msg)
{
int ii;
for (ii = msg; ii < emsg; ii++)
if (at[ii].a_type == A_DOLLAR || at[ii].a_type == A_DOLLSYM)
{
pd_error(x, "netserver: got dollar sign in message");
goto nodice;
}
if (at[msg].a_type == A_FLOAT)
{
if (emsg > msg + 1)
outlet_list(x->x_msgout, 0, emsg-msg, at + msg);
else outlet_float(x->x_msgout, at[msg].a_w.w_float);
}
else if (at[msg].a_type == A_SYMBOL)
outlet_anything(x->x_msgout, at[msg].a_w.w_symbol,
emsg-msg-1, at + msg + 1);
}
nodice:
msg = emsg + 1;
}
}
static void netserver_connectpoll(t_netserver *x)
{
struct sockaddr_in incomer_address;
int sockaddrl = (int) sizeof( struct sockaddr );
int fd = accept(x->x_connectsocket, (struct sockaddr*)&incomer_address, &sockaddrl);
if (fd < 0) post("netserver: accept failed");
else
{
t_netserver_socketreceiver *y = netserver_socketreceiver_new((void *)x,
(t_netserver_socketnotifier)netserver_notify,
(x->x_msgout ? netserver_doit : 0));
sys_addpollfn(fd, (t_fdpollfn)netserver_socketreceiver_read, y);
x->x_nconnections++;
x->x_host[x->x_nconnections - 1] = gensym(inet_ntoa(incomer_address.sin_addr));
x->x_fd[x->x_nconnections - 1] = fd;
post("netserver: ** accepted connection from %s on socket %d",
x->x_host[x->x_nconnections - 1]->s_name, x->x_fd[x->x_nconnections - 1]);
outlet_float(x->x_connectout, x->x_nconnections);
}
}
static void netserver_print(t_netserver *x)
{
int i;
if(x->x_nconnections > 0)
{
post("netserver: %d open connections:", x->x_nconnections);
for(i = 0; i < x->x_nconnections; i++)
{
post(" \"%s\" on socket %d",
x->x_host[i]->s_name, x->x_fd[i]);
}
} else post("netserver: no open connections");
}
static void *netserver_new(t_floatarg fportno)
{
t_netserver *x;
int i;
struct sockaddr_in server;
int sockfd, portno = fportno;
/* create a socket */
sockfd = socket(AF_INET, SOCK_STREAM, 0);
#if 0
post("netserver: receive socket %d", sockfd);
#endif
if (sockfd < 0)
{
sys_sockerror("socket");
return (0);
}
server.sin_family = AF_INET;
server.sin_addr.s_addr = INADDR_ANY;
#ifdef IRIX
/* this seems to work only in IRIX but is unnecessary in
Linux. Not sure what NT needs in place of this. */
if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, 0, 0) < 0)
post("setsockopt failed\n");
#endif
/* assign server port number */
server.sin_port = htons((u_short)portno);
/* name the socket */
if (bind(sockfd, (struct sockaddr *)&server, sizeof(server)) < 0)
{
sys_sockerror("bind");
sys_closesocket(sockfd);
return (0);
}
x = (t_netserver *)pd_new(netserver_class);
x->x_msgout = outlet_new(&x->x_obj, &s_anything);
/* streaming protocol */
if (listen(sockfd, 5) < 0)
{
sys_sockerror("listen");
sys_closesocket(sockfd);
sockfd = -1;
}
else
{
sys_addpollfn(sockfd, (t_fdpollfn)netserver_connectpoll, x);
x->x_connectout = outlet_new(&x->x_obj, &s_float);
x->x_clientno = outlet_new(&x->x_obj, &s_float);
x->x_connectionip = outlet_new(&x->x_obj, &s_symbol);
inbinbuf = binbuf_new();
}
x->x_connectsocket = sockfd;
x->x_nconnections = 0;
for(i = 0; i < MAX_CONNECT; i++)x->x_fd[i] = -1;
return (x);
}
static void netserver_free(t_netserver *x)
{
int i;
for(i = 0; i < x->x_nconnections; i++)
{
sys_rmpollfn(x->x_fd[i]);
sys_closesocket(x->x_fd[i]);
}
if (x->x_connectsocket >= 0)
{
sys_rmpollfn(x->x_connectsocket);
sys_closesocket(x->x_connectsocket);
}
binbuf_free(inbinbuf);
}
#ifndef MAXLIB
void netserver_setup(void)
{
netserver_class = class_new(gensym("netserver"),(t_newmethod)netserver_new, (t_method)netserver_free,
sizeof(t_netserver), 0, A_DEFFLOAT, 0);
class_addmethod(netserver_class, (t_method)netserver_print, gensym("print"), 0);
class_addmethod(netserver_class, (t_method)netserver_send, gensym("send"), A_GIMME, 0);
class_addmethod(netserver_class, (t_method)netserver_client_send, gensym("client"), A_GIMME, 0);
class_addmethod(netserver_class, (t_method)netserver_broadcast, gensym("broadcast"), A_GIMME, 0);
class_sethelpsymbol(netserver_class, gensym("help-netserver.pd"));
post(version);
}
#else
void maxlib_netserver_setup(void)
{
netserver_class = class_new(gensym("maxlib_netserver"),(t_newmethod)netserver_new, (t_method)netserver_free,
sizeof(t_netserver), 0, A_DEFFLOAT, 0);
class_addcreator((t_newmethod)netserver_new, gensym("netserver"), A_DEFFLOAT, 0);
class_addmethod(netserver_class, (t_method)netserver_print, gensym("print"), 0);
class_addmethod(netserver_class, (t_method)netserver_send, gensym("send"), A_GIMME, 0);
class_addmethod(netserver_class, (t_method)netserver_client_send, gensym("client"), A_GIMME, 0);
class_addmethod(netserver_class, (t_method)netserver_broadcast, gensym("broadcast"), A_GIMME, 0);
class_sethelpsymbol(netserver_class, gensym("maxlib/help-netserver.pd"));
}
#endif
--- NEW FILE: pitch.c ---
/* ------------------------- pitch ------------------------------------------ */
/* */
/* Get a lot of info about an incoming pitch (class, register, interval...). */
/* Written by Olaf Matthes (olaf.matthes(a)gmx.de) */
/* Get source at http://www.akustische-kunst.org/puredata/maxlib/ */
/* */
/* This program is free software; you can redistribute it and/or */
/* modify it under the terms of the GNU General Public License */
/* as published by the Free Software Foundation; either version 2 */
/* of the License, or (at your option) any later version. */
/* */
/* This program is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
/* GNU General Public License for more details. */
/* */
/* You should have received a copy of the GNU General Public License */
/* along with this program; if not, write to the Free Software */
/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/* */
/* Based on PureData by Miller Puckette and others. */
/* */
/* ---------------------------------------------------------------------------- */
#include "m_pd.h"
#include <stdio.h>
static char *version = "pitch v0.1b, written by Olaf Matthes <olaf.matthes(a)gmx.de>";
typedef struct pitch
{
t_object x_ob;
t_inlet *x_inpitch; /* inlet for pitch */
t_outlet *x_outpitchval; /* pitch as MIDI note number */
t_outlet *x_outpitchname; /* pitch name, e.g. "C1" */
t_outlet *x_outpitchclass; /* pitch class */
t_outlet *x_outintv; /* interval */
t_outlet *x_outregister; /* register */
t_int x_lastpitch;
} t_pitch;
static void pitch_float(t_pitch *x, t_floatarg f) {
char buf[8];
int r, c, interval = 0, pitch;
char* notes_up[12] = {"C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"};
char* notes_down[12] = {"C", "Db", "D", "Eb", "E", "F", "Gb", "G", "Ab", "A", "Bb", "B"};
pitch = (t_int)f;
if(pitch < 1) pitch = 0;
if(pitch > 127) pitch = 127;
if(x->x_lastpitch != 0)interval = pitch - x->x_lastpitch;
x->x_lastpitch = pitch;
r = (pitch / 12) - 1;
c = pitch % 12;
if(interval >= 0)
{
sprintf(buf, "%s%d", notes_up[c], r);
}
else
{
sprintf(buf, "%s%d", notes_down[c], r);
}
// post("note: %s %d", notes[c], r);
/* output values from right to left */
outlet_float(x->x_outregister, r);
outlet_float(x->x_outintv, interval);
outlet_float(x->x_outpitchclass, c);
outlet_symbol(x->x_outpitchname, gensym(buf));
outlet_float(x->x_outpitchval, pitch);
}
static t_class *pitch_class;
static void *pitch_new(t_floatarg f)
{
t_pitch *x = (t_pitch *)pd_new(pitch_class);
x->x_inpitch = inlet_new(&x->x_ob, &x->x_ob.ob_pd, gensym("float"), gensym("ft1"));
x->x_outpitchval = outlet_new(&x->x_ob, gensym("float"));
x->x_outpitchname = outlet_new(&x->x_ob, gensym("symbol"));
x->x_outpitchclass = outlet_new(&x->x_ob, gensym("float"));
x->x_outintv = outlet_new(&x->x_ob, gensym("float"));
x->x_outregister = outlet_new(&x->x_ob, gensym("float"));
x->x_lastpitch = f;
return (void *)x;
}
#ifndef MAXLIB
void pitch_setup(void)
{
pitch_class = class_new(gensym("pitch"), (t_newmethod)pitch_new,
0, sizeof(t_pitch), 0, A_DEFFLOAT, 0);
class_addfloat(pitch_class, pitch_float);
class_sethelpsymbol(pitch_class, gensym("help-pitch.pd"));
post(version);
}
#else
void maxlib_pitch_setup(void)
{
pitch_class = class_new(gensym("maxlib_pitch"), (t_newmethod)pitch_new,
0, sizeof(t_pitch), 0, A_DEFFLOAT, 0);
class_addcreator((t_newmethod)pitch_new, gensym("pitch"), A_DEFFLOAT, 0);
class_addfloat(pitch_class, pitch_float);
class_sethelpsymbol(pitch_class, gensym("maxlib/help-pitch.pd"));
}
#endif
--- NEW FILE: divmod.c ---
/* ------------------------- divmod ----------------------------------------- */
/* */
/* Calculates / and % together. */
/* Written by Olaf Matthes (olaf.matthes(a)gmx.de) */
/* Get source at http://www.akustische-kunst.org/puredata/maxlib/ */
/* */
/* This program is free software; you can redistribute it and/or */
/* modify it under the terms of the GNU General Public License */
/* as published by the Free Software Foundation; either version 2 */
/* of the License, or (at your option) any later version. */
/* */
/* This program is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
/* GNU General Public License for more details. */
/* */
/* You should have received a copy of the GNU General Public License */
/* along with this program; if not, write to the Free Software */
/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/* */
/* Based on PureData by Miller Puckette and others. */
/* */
/* ---------------------------------------------------------------------------- */
#include "m_pd.h"
#include <stdio.h>
static char *version = "divmod v0.1, written by Olaf Matthes <olaf.matthes(a)gmx.de>";
typedef struct divmod
{
t_object x_ob;
t_inlet *x_inleft; /* leftmost inlet */
t_inlet *x_inright; /* right inlet */
t_outlet *x_outlet1; /* result of division */
t_outlet *x_outlet2; /* result of modulo */
t_int x_leftvalue;
t_int x_rightvalue;
} t_divmod;
static void divmod_float(t_divmod *x, t_floatarg f)
{
x->x_leftvalue = (t_int)f;
outlet_float(x->x_outlet1, x->x_leftvalue / x->x_rightvalue);
outlet_float(x->x_outlet2, x->x_leftvalue % x->x_rightvalue);
}
static void divmod_ft1(t_divmod *x, t_floatarg f)
{
x->x_rightvalue = (t_int)f;
outlet_float(x->x_outlet1, x->x_leftvalue / x->x_rightvalue);
outlet_float(x->x_outlet2, x->x_leftvalue % x->x_rightvalue);
}
static void divmod_bang(t_divmod *x)
{
outlet_float(x->x_outlet1, x->x_leftvalue / x->x_rightvalue);
outlet_float(x->x_outlet2, x->x_leftvalue % x->x_rightvalue);
}
static t_class *divmod_class;
static void *divmod_new(t_floatarg fl, t_floatarg fr)
{
t_divmod *x = (t_divmod *)pd_new(divmod_class);
x->x_inright = inlet_new(&x->x_ob, &x->x_ob.ob_pd, gensym("float"), gensym("ft1"));
x->x_outlet1 = outlet_new(&x->x_ob, gensym("float"));
x->x_outlet2 = outlet_new(&x->x_ob, gensym("float"));
x->x_rightvalue = fr;
x->x_leftvalue = fl;
return (void *)x;
}
#ifndef MAXLIB
void divmod_setup(void)
{
divmod_class = class_new(gensym("divmod"), (t_newmethod)divmod_new,
0, sizeof(t_divmod), 0, A_DEFFLOAT, A_DEFFLOAT, 0);
#else
void maxlib_divmod_setup(void)
{
divmod_class = class_new(gensym("maxlib_divmod"), (t_newmethod)divmod_new,
0, sizeof(t_divmod), 0, A_DEFFLOAT, A_DEFFLOAT, 0);
#endif
class_addfloat(divmod_class, divmod_float);
class_addmethod(divmod_class, (t_method)divmod_ft1, gensym("ft1"), A_FLOAT, 0);
class_addbang(divmod_class, (t_method)divmod_bang);
#ifndef MAXLIB
class_sethelpsymbol(divmod_class, gensym("help-divmod.pd"));
post(version);
#else
class_addcreator((t_newmethod)divmod_new, gensym("divmod"), A_DEFFLOAT, A_DEFFLOAT, 0);
class_sethelpsymbol(divmod_class, gensym("maxlib/help-divmod.pd"));
#endif
}
--- NEW FILE: mlife.c ---
/* ------------------------- mlife ------------------------------------------ */
/* */
/* A linear cellular automata object for PureData. */
/* Based on 'mlife' by pauld(a)koncon.nl */
/* Written by Olaf Matthes (olaf.matthes(a)gmx.de) */
/* Get source at http://www.akustische-kunst.org/puredata/maxlib/ */
/* */
/* This program is free software; you can redistribute it and/or */
/* modify it under the terms of the GNU General Public License */
/* as published by the Free Software Foundation; either version 2 */
/* of the License, or (at your option) any later version. */
/* */
/* This program is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
/* GNU General Public License for more details. */
/* */
/* You should have received a copy of the GNU General Public License */
/* along with this program; if not, write to the Free Software */
/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/* */
/* Based on PureData by Miller Puckette and others. */
/* */
/* ---------------------------------------------------------------------------- */
#include "m_pd.h"
static char *version = "mlife v0.1, a linear cellular automata object for Pd\n"
" written by Olaf Matthes <olaf.matthes(a)gmx.de>";
#undef DEBUG
//#define DEBUG
#define INTSIZE sizeof(unsigned int) * 8
#define LONGSIZE sizeof(unsigned long) * 8
#define DEFAULT_DIE_LO 2
#define DEFAULT_DIE_HI 3
#define DEFAULT_N_SIZE 3
#define MAXSIZE 1024
#include <stdio.h>
#include <stdlib.h>
/* -------------------- random stuff -------------------- */
static union {
unsigned long next;
struct {
unsigned short : 1;
unsigned short n : 15;
} bits;
} seed = { 1 };
/*
* rand - pseudo-random number generator
*
*/
static int my_rand(void)
{
seed.next = seed.next * 1103515245 + 12345;
return(seed.bits.n);
}
/*
* srand - seed pseudo-random number generator
*
*/
static void my_srand(unsigned n)
{
seed.next = n;
}
/* --------------------------------------------------------- */
//
// Maxlife object data structure
//
typedef struct maxlife
{
t_object ml_ob; // must begin every object
t_int universe[MAXSIZE]; // array of cells - alive and dead
t_outlet *out[MAXSIZE]; // outlets
t_int size; // size of the CA field/world
t_int view_start; // Start of viewport
t_int view_size; // length of viewport and number of outlets
t_int rule_die_lo; // death if less than this
t_int rule_die_hi; // death if greater then this
t_int neighbourhood_size; // # of cells either side to check
t_int closed; // closed universe if true
} t_maxlife;
//
// Function prototypes for our methods and functions
//
static t_class *mlife_class; // global variable that points to the Maxlife class
//
// ml_nextgeneration
// Step through the array, applying the rules and reset each cell
// accordingly. For each cell:
// - Check the number of neighbours (watch for "closed")
// using neighbourhood_size
//
// - If neighbours < rule_die_lo the cell is cleared (0)
//
// - If neighbours > rule_die_hi the cell is cleared (0)
//
// - Else the cell is filled (1)
//
// not called by Pd itself
//
static void ml_nextgeneration(t_maxlife *mlp)
{
register long i, j, k;
register long size, neighbourhood_size, max_neighbours, min_neighbours, neighbours;
register int closed, out_of_bounds;
// get the important info a little closer to hand
size = mlp->size;
closed = mlp->closed;
neighbourhood_size = mlp->neighbourhood_size;
max_neighbours = mlp->rule_die_hi;
min_neighbours = mlp->rule_die_lo;
#ifdef DEBUG
post("mlife:next_generation called, vars n_size=%ld, n_max=%ld, n_min=%ld",
neighbourhood_size, max_neighbours, min_neighbours);
#endif
// for each cell...
for(i=0; i<size; i++)
{
neighbours = 0L; // reset count of neighbours
// for each neighbourhood, count the neighbours
for(j = i-neighbourhood_size; j <= i+neighbourhood_size; j++)
{
k = j; // k is the index into the array, decoupled from j
// don't go outside our array, or wrap if closed
if(closed)
{
if(j < 0)
k = size + j; // j is a negative number. size-1?
if(j > size-1L)
k = j - size - 1L; // not size-1 ???
if(j != i) // skip our own location in this roundup
if(mlp->universe[k]) // if there's a neighbour inc count
neighbours++;
}
else // not closed
{
out_of_bounds = 0;
if(k < 0L) // start of array
{
out_of_bounds = 1;
k = 0L;
}
if(k > size-1L)
{
out_of_bounds = 1;
k = size-1L; // end of array
}
if((j != i) && !out_of_bounds) // skip our own location in this roundup
if(mlp->universe[k]) // if there's a neighbour inc count
neighbours++;
}
} // end of neighbour search
// based on number of neighbours, fill or clear this cell (i)
if((neighbours < min_neighbours) || (neighbours > max_neighbours))
mlp->universe[i] = 0;
else
mlp->universe[i] = 1;
}
}
//
// method to set the die_lo number
//
static void ml_set_die_lo(t_maxlife *mlp, t_floatarg die_lo)
{
mlp->rule_die_lo = (t_int)die_lo;
}
//
// method to set the die_hi number
//
static void ml_set_die_hi(t_maxlife *mlp, t_floatarg die_hi)
{
mlp->rule_die_hi = (t_int)die_hi;
}
//
// method to set the die_lo number
//
static void ml_set_neighbourhood(t_maxlife *mlp, t_floatarg n_size)
{
mlp->neighbourhood_size = (t_int)n_size;
}
//
// bang method outputs bangs for filled cells within the view port
//
static void ml_bang(t_maxlife *mlp) // argument is a pointer to an instance
{
register long i, view_start;
#ifdef DEBUG
post("mlife:ml_bang called, sending bangs");
#endif
view_start = mlp->view_start;
// loop through the outlets right->left sending bangs if alive
for(i=view_start+mlp->view_size-2; i>=view_start-1; i--)
{
// send a bang out the appropriate outlet
if(mlp->universe[i])
outlet_bang(mlp->out[i-view_start+1]);
}
ml_nextgeneration(mlp);
}
//
// int method outputs ints for ALL cells in the view port (1=filled, 0=not)
//
static void ml_int(t_maxlife *mlp, t_floatarg dummy)
{
t_int i, view_start;
#ifdef DEBUG
post("mlife:ml_int method called");
#endif
view_start = mlp->view_start;
// loop through the outlets right -> left sending ints
for(i = view_start + mlp->view_size - 2; i >= view_start - 1; i--)
{
//outlet_int(mlp->out[i-view_start+1], mlp->universe[i]);
if(mlp->universe[i] == 1)
outlet_float(mlp->out[i-view_start+1], 1);
else if(mlp->universe[i] == 0)
outlet_float(mlp->out[i-view_start+1], 0);
else
error("mlife: corrupted data in universe[] array!");
}
ml_nextgeneration(mlp);
}
//
// method to print out the array
//
static void ml_display(t_maxlife *mlp)
{
register long i;
char s[MAXSIZE];
#ifdef DEBUG
post("mlife: display method called");
#endif
for(i = 0; i < mlp->size; i++) // print the universe array
{
//s[i] = itoa(mlp->universe[i]); // my very primitive itoa()
if(mlp->universe[i])
s[i] = '1';
else
s[i] = '0';
}
s[mlp->size] = '\0'; // null terminate the string
post("%s", s);
}
//
// method to fill the array with a number
//
static void ml_fill(t_maxlife *mlp, t_floatarg fill_no)
{
t_int n;
register long i, j;
for(i=mlp->size-1; i >= 0; i--) // fill the universe array from the back
{
n = (t_int)fill_no;
for(j=(long)INTSIZE; j>0; j--, i--, n>>=1)
{
if(i < 0L)
{
return;
}
if(n & 01)
mlp->universe[i] = 1;
else
mlp->universe[i] = 0;
}
}
}
//
// method to fill the array with a random number
//
static void ml_randfill(t_maxlife *mlp)
{
unsigned int s, rnum;
register unsigned int n;
register long i, j;
#ifdef DEBUG
post("mlife: randfill method called");
#endif
s = (unsigned int)clock_getlogicaltime(); // set seed to a new number
my_srand(s); // reseed the 'random' generator
rnum = (unsigned int)my_rand();
for(i=mlp->size - 1; i>=0; i--) // fill the universe array from the back
{
n = rnum;
for(j=(long)INTSIZE; j>0; j--, i--, n>>=1)
{
if(i < 0L)
{
return;
}
if(n & 01)
mlp->universe[i] = 1;
else
mlp->universe[i] = 0;
}
}
}
//
// method to seed the array with a number
//
static void ml_seed(t_maxlife *mlp, t_floatarg start, t_floatarg fill_no)
{
t_int n;
register long i, st, end;
#ifdef DEBUG
post("mlife: seed method called");
#endif
st = (t_int)start;
n = (t_int)fill_no;
if(st+(t_int)INTSIZE > mlp->size)
i = mlp->size - 1;
else
i = st+(long)INTSIZE - 1;
// init the universe array from the back i>=start?
for(; i >= start - 1; i--, n>>=1)
{
if(n & 01)
mlp->universe[i] = 1;
else
mlp->universe[i] = 0;
}
}
//
// method to seed the array with a random number
//
static void ml_randseed(t_maxlife *mlp, t_floatarg start)
{
unsigned long s, rnum;
register unsigned long n;
register long i, st;
#ifdef DEBUG
post("mlife: randseed method called, INTSIZE=%ld", (long)INTSIZE);
#endif
//if((start < 1) || (start > mlp->size-(long)INTSIZE))
if(start < 1)
{
error("Randseed start parameter must be between 1 and %ld", mlp->size);
return;
}
s = (unsigned long)clock_getlogicaltime(); // set seed to a new number
my_srand(s); // reseed the 'random' generator
rnum = (unsigned long)my_rand();
n = (unsigned int)rnum;
st = start;
if(st+(t_int)INTSIZE > mlp->size)
i = mlp->size - 1;
else
i = st+(t_int)INTSIZE - 1;
// init the universe array from the back
for(; i>=st-1; i--, n>>=1)
{
if(n & 01)
mlp->universe[i] = 1;
else
mlp->universe[i] = 0;
}
}
//
// function to create an instance of the mlife class
//
static void *ml_new(t_floatarg size, t_floatarg view_start, t_floatarg view_size, t_floatarg closed)
{
long i;
t_maxlife *mlp = (t_maxlife *)pd_new(mlife_class);
// check all args...
if((size>MAXSIZE) || (size<1))
{
post("mlife: size argument must be between 1 and %ld", MAXSIZE);
size = 1.0;
}
if(view_start < 1)
{
post("mlife: view_start argument must be between 1 and %ld", size);
view_start = 1.0;
}
if((view_size < 1) || (view_size+view_start > size+1))
{
post("mlife: viewsize argument must be between 1 and %ld", size-view_start);
view_size = 1.0;
}
// set up our structure
mlp->size = (t_int)size;
mlp->view_start = (t_int)view_start;
mlp->view_size = (t_int)view_size;
mlp->rule_die_lo = DEFAULT_DIE_LO; // 2
mlp->rule_die_hi = DEFAULT_DIE_HI; // 3
mlp->neighbourhood_size = DEFAULT_N_SIZE; // 3
mlp->closed = (t_int)closed;
for(i=0; i<MAXSIZE; i++)
mlp->universe[i] = 0;
// create outlets - last first!
for(i = 0; i < mlp->view_size; i++)
mlp->out[i] = outlet_new(&mlp->ml_ob, gensym("float"));
#ifdef DEBUG
post("mlife: finished building object");
post("mlife: INTSIZE=%ld, LONGSIZE=%ld", (long)INTSIZE, (long)LONGSIZE);
#endif
post("mlife: defaults are: lo=%ld, hi=%ld, nset=%ld", (long)DEFAULT_DIE_LO, (long)DEFAULT_DIE_HI, DEFAULT_N_SIZE);
return(mlp); // always return a copy of the created object
}
static void ml_free(t_maxlife *mlp)
{
long i;
#ifdef DEBUG
post("mlife:freeing outlet memory");
#endif
/* for(i=mlp->view_size-1; i>=0; i--)
freeobject(mlp->out[i]); */
}
#ifndef MAXLIB
void mlife_setup(void)
{
mlife_class = class_new(gensym("mlife"), (t_newmethod)ml_new,
(t_method)ml_free, sizeof(t_maxlife), 0, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0);
class_addmethod(mlife_class, (t_method)ml_randfill, gensym("randfill"), 0);
class_addmethod(mlife_class, (t_method)ml_fill, gensym("fill"), A_FLOAT, 0);
class_addmethod(mlife_class, (t_method)ml_set_die_lo, gensym("lo"), A_FLOAT, 0);
class_addmethod(mlife_class, (t_method)ml_set_die_hi, gensym("hi"), A_FLOAT, 0);
class_addmethod(mlife_class, (t_method)ml_set_neighbourhood, gensym("nset"), A_FLOAT, 0);
class_addmethod(mlife_class, (t_method)ml_randseed, gensym("randseed"), A_FLOAT, 0);
class_addmethod(mlife_class, (t_method)ml_seed, gensym("seed"), A_FLOAT, A_FLOAT, 0);
class_addmethod(mlife_class, (t_method)ml_display, gensym("display"), 0);
class_addfloat(mlife_class, ml_int);
class_addbang(mlife_class, ml_bang);
class_sethelpsymbol(mlife_class, gensym("help-mlife.pd"));
post(version);
}
#else
void maxlib_mlife_setup(void)
{
mlife_class = class_new(gensym("maxlib_mlife"), (t_newmethod)ml_new,
(t_method)ml_free, sizeof(t_maxlife), 0, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0);
class_addcreator((t_newmethod)ml_new, gensym("mlife"), A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0);
class_addmethod(mlife_class, (t_method)ml_randfill, gensym("randfill"), 0);
class_addmethod(mlife_class, (t_method)ml_fill, gensym("fill"), A_FLOAT, 0);
class_addmethod(mlife_class, (t_method)ml_set_die_lo, gensym("lo"), A_FLOAT, 0);
class_addmethod(mlife_class, (t_method)ml_set_die_hi, gensym("hi"), A_FLOAT, 0);
class_addmethod(mlife_class, (t_method)ml_set_neighbourhood, gensym("nset"), A_FLOAT, 0);
class_addmethod(mlife_class, (t_method)ml_randseed, gensym("randseed"), A_FLOAT, 0);
class_addmethod(mlife_class, (t_method)ml_seed, gensym("seed"), A_FLOAT, A_FLOAT, 0);
class_addmethod(mlife_class, (t_method)ml_display, gensym("display"), 0);
class_addfloat(mlife_class, ml_int);
class_addbang(mlife_class, ml_bang);
class_sethelpsymbol(mlife_class, gensym("maxlib/help-mlife.pd"));
}
#endif
--- NEW FILE: deny.c ---
/* ---------------------------- deny --------------------------------------- */
/* */
/* Lets only floats/symbols through that are denyed to do so. */
/* Written by Olaf Matthes <olaf.matthes(a)gmx.de> */
/* Get source at http://www.akustische-kunst.org/puredata/maxlib/ */
/* */
/* This program is free software; you can redistribute it and/or */
/* modify it under the terms of the GNU General Public License */
/* as published by the Free Software Foundation; either version 2 */
/* of the License, or (at your option) any later version. */
/* */
/* This program is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
/* GNU General Public License for more details. */
/* */
/* You should have received a copy of the GNU General Public License */
/* along with this program; if not, write to the Free Software */
/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/* */
/* Based on PureData by Miller Puckette and others. */
/* */
/* ---------------------------------------------------------------------------- */
#include "m_pd.h"
#include <string.h>
static char *version = "deny v0.1, written by Olaf Matthes <olaf.matthes(a)gmx.de>";
typedef struct deny
{
t_object x_obj;
t_outlet *x_out;
t_atom *x_elem; // list of elemets that are denyed to pass
t_int x_numelem; // the number of elemetns in our deny-list
} t_deny;
/* we got a symbol... */
static void deny_symbol(t_deny *x, t_symbol *s)
{
int i, deny = 0;
for(i = 0; i < x->x_numelem; i++)
{
if(x->x_elem[i].a_type == A_SYMBOL) // compare with all symbols in our list
if(atom_getsymbolarg(i, x->x_numelem, x->x_elem) == s)
{
deny = 1;
return;
}
}
if(!deny)outlet_symbol(x->x_out, s);
}
/* we got a float... */
static void deny_float(t_deny *x, t_floatarg f)
{
int i, deny = 0;
for(i = 0; i < x->x_numelem; i++)
{
if(x->x_elem[i].a_type == A_FLOAT) // compare with all floats in our list
if(atom_getfloatarg(i, x->x_numelem, x->x_elem) == f)
{
deny = 1; // input is in deny-list
return;
}
}
if(!deny)outlet_float(x->x_out, f);
}
static t_class *deny_class;
static void deny_free(t_deny *x)
{
freebytes(x->x_elem, x->x_numelem*sizeof(t_atom));
}
static void *deny_new(t_symbol *s, int argc, t_atom *argv)
{
t_deny *x = (t_deny *)pd_new(deny_class);
x->x_numelem = argc; // get the number of elements
x->x_elem = getbytes(argc*sizeof(t_atom));
memcpy(x->x_elem, argv, argc*sizeof(t_atom));
x->x_out = outlet_new(&x->x_obj, gensym("anything"));
// post("deny: got %d elements", x->x_numelem);
return (x);
}
#ifndef MAXLIB
void deny_setup(void)
{
/* the object's class: */
deny_class = class_new(gensym("deny"), (t_newmethod)deny_new,
(t_method)deny_free, sizeof(t_deny), 0, A_GIMME, 0);
#else
void maxlib_deny_setup(void)
{
/* the object's class: */
deny_class = class_new(gensym("maxlib_deny"), (t_newmethod)deny_new,
(t_method)deny_free, sizeof(t_deny), 0, A_GIMME, 0);
class_addcreator((t_newmethod)deny_new, gensym("deny"), A_GIMME, 0);
#endif
class_addsymbol(deny_class, deny_symbol);
class_addfloat(deny_class, deny_float);
#ifndef MAXLIB
class_sethelpsymbol(deny_class, gensym("help-deny.pd"));
post(version);
#else
class_sethelpsymbol(deny_class, gensym("maxlib/help-deny.pd"));
#endif
}
--- NEW FILE: divide.c ---
/* ------------------------- divide ------------------------------------------ */
/* */
/* Like '/', but calculates output whenever _any_ of the inlets changes. */
/* Written by Olaf Matthes (olaf.matthes(a)gmx.de) */
/* Get source at http://www.akustische-kunst.org/puredata/maxlib/ */
/* */
/* This program is free software; you can redistribute it and/or */
/* modify it under the terms of the GNU General Public License */
/* as published by the Free Software Foundation; either version 2 */
/* of the License, or (at your option) any later version. */
/* */
/* This program is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
/* GNU General Public License for more details. */
/* */
/* You should have received a copy of the GNU General Public License */
/* along with this program; if not, write to the Free Software */
/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/* */
/* Based on PureData by Miller Puckette and others. */
/* */
/* ---------------------------------------------------------------------------- */
#include "m_pd.h"
#include <stdio.h>
#define MAXSIZE 32
static char *version = "divide v0.2, written by Olaf Matthes <olaf.matthes(a)gmx.de>";
typedef struct divide
{
t_object x_ob;
t_inlet *x_inleft; /* leftmost inlet */
t_inlet *x_inright; /* right inlet */
t_outlet *x_outlet; /* result */
t_int x_numvalues; /* number of values / inlets */
t_float x_dividevalue[MAXSIZE];
} t_divide;
static void divide_bang(t_divide *x)
{
int i;
t_float result = x->x_dividevalue[0];
for(i = 1; i < x->x_numvalues; i++)
result /= x->x_dividevalue[i];
outlet_float(x->x_outlet, result);
}
static void divide_float(t_divide *x, t_floatarg f)
{
x->x_dividevalue[0] = f;
divide_bang(x); /* calculate result */
}
static void divide_ft1(t_divide *x, t_floatarg f)
{
x->x_dividevalue[1] = f;
divide_bang(x); /* calculate result */
}
static t_class *divide_class;
static void *divide_new(t_symbol *s, t_int argc, t_atom* argv)
{
int i;
t_divide *x = (t_divide *)pd_new(divide_class);
x->x_inright = inlet_new(&x->x_ob, &x->x_ob.ob_pd, gensym("float"), gensym("ft1"));
for(i = 2; i < argc; i++) /* create additional inlets, if any */
{
floatinlet_new(&x->x_ob, &x->x_dividevalue[i]);
}
x->x_outlet = outlet_new(&x->x_ob, gensym("float"));
for(i = 0; i < argc; i++)
{
x->x_dividevalue[i] = atom_getfloatarg(i, argc, argv);
}
x->x_numvalues = i;
return (void *)x;
}
#ifndef MAXLIB
void divide_setup(void)
{
divide_class = class_new(gensym("divide"), (t_newmethod)divide_new,
0, sizeof(t_divide), 0, A_GIMME, 0);
#else
void maxlib_divide_setup(void)
{
divide_class = class_new(gensym("maxlib_divide"), (t_newmethod)divide_new,
0, sizeof(t_divide), 0, A_GIMME, 0);
#endif
class_addfloat(divide_class, divide_float);
class_addmethod(divide_class, (t_method)divide_ft1, gensym("ft1"), A_FLOAT, 0);
class_addbang(divide_class, (t_method)divide_bang);
#ifndef MAXLIB
class_sethelpsymbol(divide_class, gensym("help-divide.pd"));
post(version);
#else
class_addcreator((t_newmethod)divide_new, gensym("divide"), A_GIMME, 0);
class_sethelpsymbol(divide_class, gensym("maxlib/help-divide.pd"));
#endif
}
--- NEW FILE: linear.c ---
/* ---------------------------- rand_linear ----------------------------------- */
/* */
/* rand_linear generates a linearly distributed random variable. */
/* Written by Olaf Matthes (olaf.matthes(a)gmx.de) */
/* Based on code found in Dodge/Jerse "Computer Music" */
/* Get source at http://www.akustische-kunst.org/puredata/maxlib/ */
/* */
/* This program is free software; you can redistribute it and/or */
/* modify it under the terms of the GNU General Public License */
/* as published by the Free Software Foundation; either version 2 */
/* of the License, or (at your option) any later version. */
/* */
/* This program is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
/* GNU General Public License for more details. */
/* */
/* You should have received a copy of the GNU General Public License */
/* along with this program; if not, write to the Free Software */
/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/* */
/* Based on PureData by Miller Puckette and others. */
/* */
/* ---------------------------------------------------------------------------- */
#include "m_pd.h"
#include <stdlib.h>
#include <time.h>
#include <math.h>
#define fran() (t_float)rand()/(t_float)RAND_MAX
static char *version = "linear v0.1, generates linearly distributed random variable\n"
" written by Olaf Matthes <olaf.matthes(a)gmx.de>";
/* -------------------------- rand_linear ------------------------------ */
static t_class *rand_linear_class;
typedef struct _rand_linear
{
t_object x_obj;
} t_rand_linear;
static void *rand_linear_new(t_floatarg f)
{
t_rand_linear *x = (t_rand_linear *)pd_new(rand_linear_class);
srand( (unsigned)time( NULL ) );
outlet_new(&x->x_obj, &s_float);
return (x);
}
static void rand_linear_bang(t_rand_linear *x)
{
t_float u1, u2;
u1 = fran();
u2 = fran();
if(u2 < u1)
u1 = u2;
outlet_float(x->x_obj.ob_outlet, u1);
}
#ifndef MAXLIB
void linear_setup(void)
{
rand_linear_class = class_new(gensym("linear"), (t_newmethod)rand_linear_new, 0,
sizeof(t_rand_linear), 0, A_DEFFLOAT, 0);
class_addbang(rand_linear_class, rand_linear_bang);
class_sethelpsymbol(rand_linear_class, gensym("help-linear.pd"));
post(version);
}
#else
void maxlib_linear_setup(void)
{
rand_linear_class = class_new(gensym("maxlib_linear"), (t_newmethod)rand_linear_new, 0,
sizeof(t_rand_linear), 0, A_DEFFLOAT, 0);
class_addcreator((t_newmethod)rand_linear_new, gensym("linear"), A_DEFFLOAT, 0);
class_addbang(rand_linear_class, rand_linear_bang);
class_sethelpsymbol(rand_linear_class, gensym("maxlib/help-linear.pd"));
}
#endif
--- NEW FILE: multi.c ---
/* -------------------------- multi ------------------------------------------ */
/* */
/* Like '*', but calculates output whenever _any_ of the inlets changes. */
/* Written by Olaf Matthes (olaf.matthes(a)gmx.de) */
/* Get source at http://www.akustische-kunst.org/puredata/maxlib/ */
/* */
/* This program is free software; you can redistribute it and/or */
/* modify it under the terms of the GNU General Public License */
/* as published by the Free Software Foundation; either version 2 */
/* of the License, or (at your option) any later version. */
/* */
/* This program is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
/* GNU General Public License for more details. */
/* */
/* You should have received a copy of the GNU General Public License */
/* along with this program; if not, write to the Free Software */
/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/* */
/* Based on PureData by Miller Puckette and others. */
/* */
/* ---------------------------------------------------------------------------- */
#include "m_pd.h"
#include <stdio.h>
#define MAXSIZE 32
static char *version = "multi v0.2, written by Olaf Matthes <olaf.matthes(a)gmx.de>";
typedef struct multi
{
t_object x_ob;
t_inlet *x_inleft; /* leftmost inlet */
t_inlet *x_inright; /* right inlet */
t_outlet *x_outlet; /* result */
t_int x_numvalues; /* number of values / inlets */
t_float x_multivalue[MAXSIZE];
} t_multi;
static void multi_bang(t_multi *x)
{
int i;
t_float result = x->x_multivalue[0];
for(i = 1; i < x->x_numvalues; i++)
result *= x->x_multivalue[i];
outlet_float(x->x_outlet, result);
}
static void multi_float(t_multi *x, t_floatarg f)
{
x->x_multivalue[0] = f;
multi_bang(x); /* calculate result */
}
static void multi_ft1(t_multi *x, t_floatarg f)
{
x->x_multivalue[1] = f;
multi_bang(x); /* calculate result */
}
static t_class *multi_class;
static void *multi_new(t_symbol *s, t_int argc, t_atom* argv)
{
int i;
t_multi *x = (t_multi *)pd_new(multi_class);
x->x_inright = inlet_new(&x->x_ob, &x->x_ob.ob_pd, gensym("float"), gensym("ft1"));
for(i = 2; i < argc; i++) /* create additional inlets, if any */
{
floatinlet_new(&x->x_ob, &x->x_multivalue[i]);
}
x->x_outlet = outlet_new(&x->x_ob, gensym("float"));
for(i = 0; i < argc; i++)
{
x->x_multivalue[i] = atom_getfloatarg(i, argc, argv);;
}
x->x_numvalues = i;
return (void *)x;
}
#ifndef MAXLIB
void multi_setup(void)
{
multi_class = class_new(gensym("multi"), (t_newmethod)multi_new,
0, sizeof(t_multi), 0, A_GIMME, 0);
class_addfloat(multi_class, multi_float);
class_addmethod(multi_class, (t_method)multi_ft1, gensym("ft1"), A_FLOAT, 0);
class_addbang(multi_class, (t_method)multi_bang);
class_sethelpsymbol(multi_class, gensym("help-multi.pd"));
post(version);
}
#else
void maxlib_multi_setup(void)
{
multi_class = class_new(gensym("maxlib_multi"), (t_newmethod)multi_new,
0, sizeof(t_multi), 0, A_GIMME, 0);
class_addcreator((t_newmethod)multi_new, gensym("multi"), A_GIMME, 0);
class_addfloat(multi_class, multi_float);
class_addmethod(multi_class, (t_method)multi_ft1, gensym("ft1"), A_FLOAT, 0);
class_addbang(multi_class, (t_method)multi_bang);
class_sethelpsymbol(multi_class, gensym("maxlib/help-multi.pd"));
}
#endif
--- NEW FILE: minus.c ---
/* ------------------------- minus ------------------------------------------ */
/* */
/* Like '-', but calculates output whenever _any_ of the inlets changes. */
/* Written by Olaf Matthes (olaf.matthes(a)gmx.de) */
/* Get source at http://www.akustische-kunst.org/puredata/maxlib/ */
/* */
/* This program is free software; you can redistribute it and/or */
/* modify it under the terms of the GNU General Public License */
/* as published by the Free Software Foundation; either version 2 */
/* of the License, or (at your option) any later version. */
/* */
/* This program is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
/* GNU General Public License for more details. */
/* */
/* You should have received a copy of the GNU General Public License */
/* along with this program; if not, write to the Free Software */
/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/* */
/* Based on PureData by Miller Puckette and others. */
/* */
/* ---------------------------------------------------------------------------- */
#include "m_pd.h"
#include <stdio.h>
#define MAXSIZE 32
static char *version = "minus v0.2, written by Olaf Matthes <olaf.matthes(a)gmx.de>";
typedef struct minus
{
t_object x_ob;
t_inlet *x_inleft; /* leftmost inlet */
t_inlet *x_inright; /* right inlet */
t_outlet *x_outlet; /* result */
t_int x_numvalues; /* number of values / inlets */
t_float x_minusvalue[MAXSIZE];
} t_minus;
static void minus_bang(t_minus *x)
{
int i;
t_float result = x->x_minusvalue[0];
for(i = 1; i < x->x_numvalues; i++)
result -= x->x_minusvalue[i];
outlet_float(x->x_outlet, result);
}
static void minus_float(t_minus *x, t_floatarg f)
{
x->x_minusvalue[0] = f;
minus_bang(x); /* calculate result */
}
static void minus_ft1(t_minus *x, t_floatarg f)
{
x->x_minusvalue[1] = f;
minus_bang(x); /* calculate result */
}
static t_class *minus_class;
static void *minus_new(t_symbol *s, t_int argc, t_atom* argv)
{
int i;
t_minus *x = (t_minus *)pd_new(minus_class);
x->x_inright = inlet_new(&x->x_ob, &x->x_ob.ob_pd, gensym("float"), gensym("ft1"));
for(i = 2; i < argc; i++) /* create additional inlets, if any */
{
// inlet_new(&x->x_ob, &x->x_ob.ob_pd, gensym("float"), gensym("ft1"));
floatinlet_new(&x->x_ob, &x->x_minusvalue[i]);
}
x->x_outlet = outlet_new(&x->x_ob, gensym("float"));
for(i = 0; i < argc; i++)
{
x->x_minusvalue[i] = atom_getfloatarg(i, argc, argv);
}
x->x_numvalues = i;
return (void *)x;
}
#ifndef MAXLIB
void minus_setup(void)
{
minus_class = class_new(gensym("minus"), (t_newmethod)minus_new,
0, sizeof(t_minus), 0, A_GIMME, 0);
class_addfloat(minus_class, minus_float);
class_addmethod(minus_class, (t_method)minus_ft1, gensym("ft1"), A_FLOAT, 0);
class_addbang(minus_class, (t_method)minus_bang);
class_sethelpsymbol(minus_class, gensym("help-minus.pd"));
post(version);
}
#else
void maxlib_minus_setup(void)
{
minus_class = class_new(gensym("maxlib_minus"), (t_newmethod)minus_new,
0, sizeof(t_minus), 0, A_GIMME, 0);
class_addcreator((t_newmethod)minus_new, gensym("minus"), A_GIMME, 0);
class_addfloat(minus_class, minus_float);
class_addmethod(minus_class, (t_method)minus_ft1, gensym("ft1"), A_FLOAT, 0);
class_addbang(minus_class, (t_method)minus_bang);
class_sethelpsymbol(minus_class, gensym("maxlib/help-minus.pd"));
}
#endif
--- NEW FILE: arbran.c ---
/* ---------------------------- rand_arbran ----------------------------------- */
/* */
/* rand_arbran generates a random variable that conforms to the */
/* piecewise probability density in two arrays */
/* Written by Olaf Matthes (olaf.matthes(a)gmx.de) */
/* Based on code found in Dodge/Jerse "Computer Music" */
/* Get source at http://www.akustische-kunst.org/puredata/maxlib/ */
/* */
/* This program is free software; you can redistribute it and/or */
/* modify it under the terms of the GNU General Public License */
/* as published by the Free Software Foundation; either version 2 */
/* of the License, or (at your option) any later version. */
/* */
/* This program is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
/* GNU General Public License for more details. */
/* */
/* You should have received a copy of the GNU General Public License */
/* along with this program; if not, write to the Free Software */
/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/* */
/* Based on PureData by Miller Puckette and others. */
/* */
/* ---------------------------------------------------------------------------- */
#include "m_pd.h"
#include <stdlib.h>
#include <time.h>
#include <math.h>
#define fran() (t_float)rand()/(t_float)RAND_MAX
#ifndef M_PI
#define M_PI 3.1415927
#endif
static char *version = "arbran v0.1b, generates a random variable that conforms to the\n"
" piecewise probability density in two arrays\n"
" written by Olaf Matthes <olaf.matthes(a)gmx.de>";
/* -------------------------- rand_arbran ------------------------------ */
static t_class *rand_arbran_class;
typedef struct _rand_arbran
{
t_object x_obj;
t_symbol *x_x;
t_symbol *x_p;
t_garray *x_bufx;
t_garray *x_bufp;
} t_rand_arbran;
static void rand_arbran_pdfscale(t_rand_arbran *x)
{
t_garray *bx = x->x_bufx, *bp = x->x_bufp;
t_float a = 0;
t_int k = 0;
t_float *tx, *tp;
t_int ix, ip;
if (!garray_getfloatarray(bx, &ix, &tx))
{
post("arbran: couldn't read from array!");
return;
}
if (!garray_getfloatarray(bp, &ip, &tp))
{
post("arbran: couldn't read from array!");
return;
}
for(k = 1; k < ix; k++)
{
a += (tx[k]-tx[k-1])*(tp[k]+tp[k-1])/2.0;
}
for(k = 0; k < ix; k++)
{
tp[k] = tp[k]/a;
}
garray_redraw(x->x_bufp);
}
static void rand_arbran_bang(t_rand_arbran *x)
{
t_garray *bx = x->x_bufx, *bp = x->x_bufp;
t_float a, u, a0, slope, b, d, r;
t_int k = 0;
t_float *tx, *tp;
t_int ix, ip;
if (!garray_getfloatarray(bx, &ix, &tx))
{
post("arbran: couldn't read from array!");
return;
}
if (!garray_getfloatarray(bp, &ip, &tp))
{
post("arbran: couldn't read from array!");
return;
}
a = 0;
a0 = 0;
u = fran();
while(u > a)
{
a0 = (tx[k+1]-tx[k])*(tp[k+1]+tp[k])/2.0;
a += a0;
k++;
}
k--;
slope = (tp[k+1]-tp[k])/(tx[k+1]-tx[k]);
if(slope == 0)
{
r = (u-a+a0)/tp[k]+tx[k];
}
else
{
b=tp[k]/slope-tx[k];
d=b*b+tx[k]*tx[k]+2*b*tx[k]+2*(u-a+a0)/slope;
if(slope > 0)
r=-b+sqrt(d);
else
r=-b-sqrt(d);
}
outlet_float(x->x_obj.ob_outlet, r);
}
static void rand_arbran_set(t_rand_arbran *x)
{
t_garray *b, *b2;
if ((b = (t_garray *)pd_findbyclass(x->x_x, garray_class)))
{
post("arbran: array set to \"%s\"", x->x_x->s_name);
x->x_bufx = b;
} else {
post("arbran: no array \"%s\" (error %d)", x->x_x->s_name, b);
x->x_bufx = 0;
}
if ((b2 = (t_garray *)pd_findbyclass(x->x_p, garray_class)))
{
post("arbran: array set to \"%s\"", x->x_p->s_name);
x->x_bufp = b2;
} else {
post("arbran: no array \"%s\" (error %d)", x->x_p->s_name, b);
x->x_bufp = 0;
}
}
static void rand_arbran_setarrays(t_rand_arbran *x, t_symbol *s1, t_symbol *s2)
{
x->x_x = s1;
x->x_p = s2;
rand_arbran_set(x);
}
static void *rand_arbran_new(t_symbol *s1, t_symbol *s2)
{
t_rand_arbran *x = (t_rand_arbran *)pd_new(rand_arbran_class);
srand( (unsigned)time( NULL ) );
outlet_new(&x->x_obj, &s_float);
x->x_x = s1;
x->x_p = s2;
rand_arbran_set(x);
return (x);
}
#ifndef MAXLIB
void arbran_setup(void)
{
rand_arbran_class = class_new(gensym("arbran"), (t_newmethod)rand_arbran_new, 0,
sizeof(t_rand_arbran), 0, A_SYMBOL, A_SYMBOL, 0);
#else
void maxlib_arbran_setup(void)
{
rand_arbran_class = class_new(gensym("maxlib_arbran"), (t_newmethod)rand_arbran_new, 0,
sizeof(t_rand_arbran), 0, A_SYMBOL, A_SYMBOL, 0);
#endif
class_addbang(rand_arbran_class, rand_arbran_bang);
class_addmethod(rand_arbran_class, (t_method)rand_arbran_pdfscale, gensym("pdfscale"), 0);
class_addmethod(rand_arbran_class, (t_method)rand_arbran_setarrays, gensym("set"), A_SYMBOL, A_SYMBOL, 0);
#ifndef MAXLIB
class_sethelpsymbol(rand_arbran_class, gensym("help-arbran.pd"));
post(version);
#else
class_addcreator((t_newmethod)rand_arbran_new, gensym("arbran"), A_SYMBOL, A_SYMBOL, 0);
class_sethelpsymbol(rand_arbran_class, gensym("maxlib/help-arbran.pd"));
#endif
}
--- NEW FILE: history.c ---
/* -------------------------- history ----------------------------------------- */
/* */
/* Calculates the average value of the elements within the last N seconds. */
/* Written by Olaf Matthes (olaf.matthes(a)gmx.de) */
/* Get source at http://www.akustische-kunst.org/puredata/maxlib/ */
/* */
/* This program is free software; you can redistribute it and/or */
/* modify it under the terms of the GNU General Public License */
/* as published by the Free Software Foundation; either version 2 */
/* of the License, or (at your option) any later version. */
/* */
/* This program is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
/* GNU General Public License for more details. */
/* */
/* You should have received a copy of the GNU General Public License */
/* along with this program; if not, write to the Free Software */
/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/* */
/* Based on PureData by Miller Puckette and others. */
/* */
/* ---------------------------------------------------------------------------- */
#include "m_pd.h"
#include <math.h>
#define MAX_ARG 1024 /* maximum number of items to average */
#define MAX_TIME 60000 /* maximum time to look back */
static char *version = "history v0.1, written by Olaf Matthes <olaf.matthes(a)gmx.de>";
typedef struct history
{
t_object x_ob;
t_clock *x_clock;
t_inlet *x_inindex;
t_outlet *x_outfloat; /* output the history */
t_outlet *x_outtendency; /* outputs the tendency of the average */
t_int x_limit; /* indicates if input is 'blocked' (1) */
t_int x_index; /* the number of elements to average */
t_float x_input[MAX_ARG]; /* stores the input values we need for averaging */
double x_intime[MAX_ARG]; /* stores the time of arrival of an element */
t_int x_inpointer; /* actual position in above array */
t_float x_average; /* what do you guess ? */
t_float x_lastaverage;
t_int x_mode; /* how to history: linear or geometric */
t_int x_time;
} t_history;
/* there must be a function for this in math.h but how is the
german 'Fakultät' called in english ???? */
static int normalise(int i)
{
int ret = i;
while(i--)
{
if(i == 0)break;
ret += i;
}
return (ret);
}
static void history_tick(t_history *x)
{
t_float tendency = 0.0;
if(x->x_lastaverage < x->x_average)
{
tendency = 1.0; /* getting more */
}
else if(x->x_lastaverage > x->x_average)
{
tendency = -1.0; /* getting less */
}
else tendency = 0.0; /* nothing has changed */
outlet_float(x->x_outtendency, tendency);
x->x_lastaverage = x->x_average;
clock_delay(x->x_clock, x->x_time);
}
static void history_float(t_history *x, t_floatarg f)
{
int i, j = 0, k = 0, l;
t_float geo = 1.0;
x->x_average = 0;
/* put value into array */
x->x_input[x->x_inpointer] = f;
x->x_intime[x->x_inpointer] = clock_getlogicaltime();
/* look for elements that are too old */
x->x_index = 0;
for(i = 0; i < MAX_ARG; i++) /* check all valid elements */
{
if(x->x_intime[i] != 0)
{
if(clock_gettimesince(x->x_intime[i]) <= x->x_time) /* it's in our time window */
{
x->x_index++; /* count valid entries */
}
else /* too old, delete entry */
{
x->x_intime[i] = 0;
}
}
}
if(x->x_index > 1)
{
/* calulate history */
for(i = 0; i < MAX_ARG; i++) /* check all valid elements */
{
if(x->x_intime[i] != 0) /* it's a valid entry */
{
k++;
l = MAX_ARG;
if(x->x_mode == 0) /* linear */
{
x->x_average += x->x_input[i] * (1.0 / (float)x->x_index);
}
else if(x->x_mode == 1) /* geometric */
{
if(x->x_input[i] == 0)x->x_input[i] = 0.001; /* need to cheat a bit... */
geo *= x->x_input[i];
if(k == x->x_index)
x->x_average = pow(geo, (1.0/(float)x->x_index));
}
else if(x->x_mode == 2) /* weighted */
{
/* normalise output */
if(k == x->x_index)
{
x->x_average += x->x_input[(j + x->x_inpointer + MAX_ARG) % MAX_ARG] * (float)(x->x_index - k);
x->x_average = x->x_average / (float)normalise(x->x_index - 1);
}
else
{
x->x_average += x->x_input[(j + x->x_inpointer + MAX_ARG) % MAX_ARG] * (float)(x->x_index - k);
j--; /* go back in array */
while(l--) /* check if this will result in a valid value */
{
if(x->x_intime[(j + x->x_inpointer + MAX_ARG) % MAX_ARG] == 0)
{
j--; /* go back more if necessary */
}
else break; /* finished on first non-zero */
}
}
} else post("history: internal error!");
}
}
}
else x->x_average = x->x_input[x->x_inpointer];
if(++x->x_inpointer > MAX_ARG)
{
x->x_inpointer = 0;
}
outlet_float(x->x_outfloat, x->x_average);
}
static void history_time(t_history *x, t_floatarg f)
{
x->x_time = (t_int)f;
if(x->x_time < 1) x->x_time = 1;
if(x->x_time > MAX_TIME)x->x_time = MAX_TIME;
clock_unset(x->x_clock);
clock_delay(x->x_clock, 0);
}
static void history_reset(t_history *x)
{
int i;
/* zeroe out the array */
for(i = 0; i < MAX_ARG; i++)
{
x->x_input[i] = 0.0;
x->x_intime[i] = 0.0;
}
x->x_index = 0;
x->x_inpointer = 0;
x->x_average = 0;
x->x_lastaverage = 0;
post("history: reset");
}
static void history_linear(t_history *x)
{
x->x_mode = 0;
post("history: linear");
}
static void history_geometric(t_history *x)
{
x->x_mode = 1;
post("history: geometric");
}
static void history_weight(t_history *x)
{
x->x_mode = 2;
post("history: weighted");
}
static void history_free(t_history *x)
{
clock_free(x->x_clock);
}
static t_class *history_class;
static void *history_new(t_floatarg f)
{
int i;
t_history *x = (t_history *)pd_new(history_class);
x->x_inindex = inlet_new(&x->x_ob, &x->x_ob.ob_pd, gensym("float"), gensym("time"));
x->x_outfloat = outlet_new(&x->x_ob, gensym("float"));
x->x_outtendency = outlet_new(&x->x_ob, gensym("float"));
x->x_clock = clock_new(x, (t_method)history_tick);
/* zeroe out the array */
for(i = 0; i < MAX_ARG; i++)
{
x->x_input[i] = 0.0;
x->x_intime[i] = 0.0;
}
x->x_time = (t_int)f;
if(x->x_time < 1) x->x_time = 1;
if(x->x_time > MAX_TIME)
{
x->x_time = MAX_TIME;
post("history: set number time to %d", x->x_time);
}
x->x_index = 0;
x->x_inpointer = 0;
x->x_average = 0;
x->x_mode = 0;
clock_delay(x->x_clock, 0);
return (void *)x;
}
#ifndef MAXLIB
void history_setup(void)
{
history_class = class_new(gensym("history"), (t_newmethod)history_new,
(t_method)history_free, sizeof(t_history), 0, A_DEFFLOAT, 0);
class_addmethod(history_class, (t_method)history_reset, gensym("reset"), 0);
class_addmethod(history_class, (t_method)history_linear, gensym("linear"), 0);
class_addmethod(history_class, (t_method)history_geometric, gensym("geometric"), 0);
class_addmethod(history_class, (t_method)history_weight, gensym("weight"), 0);
class_addfloat(history_class, history_float);
class_addmethod(history_class, (t_method)history_time, gensym("time"), A_FLOAT, 0);
class_sethelpsymbol(history_class, gensym("help-history.pd"));
post(version);
}
#else
void maxlib_history_setup(void)
{
history_class = class_new(gensym("maxlib_history"), (t_newmethod)history_new,
(t_method)history_free, sizeof(t_history), 0, A_DEFFLOAT, 0);
class_addcreator((t_newmethod)history_new, gensym("history"), A_DEFFLOAT, 0);
class_addmethod(history_class, (t_method)history_reset, gensym("reset"), 0);
class_addmethod(history_class, (t_method)history_linear, gensym("linear"), 0);
class_addmethod(history_class, (t_method)history_geometric, gensym("geometric"), 0);
class_addmethod(history_class, (t_method)history_weight, gensym("weight"), 0);
class_addfloat(history_class, history_float);
class_addmethod(history_class, (t_method)history_time, gensym("time"), A_FLOAT, 0);
class_sethelpsymbol(history_class, gensym("maxlib/help-history.pd"));
}
#endif
--- NEW FILE: match.c ---
/* ------------------------- match ------------------------------------------ */
/* */
/* Outputs a list when a list of input values matches the creation args. */
/* Written by Krzysztof Czaja for his cyclone library. */
/* Modified to fit into maxlib by Olaf Matthes <olaf.matthes(a)gmx.de>. */
/* Get source at http://www.akustische-kunst.org/puredata/maxlib/ */
/* */
/* This program is free software; you can redistribute it and/or */
/* modify it under the terms of the GNU General Public License */
/* as published by the Free Software Foundation; either version 2 */
/* of the License, or (at your option) any later version. */
/* */
/* This program is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
/* GNU General Public License for more details. */
/* */
/* You should have received a copy of the GNU General Public License */
/* along with this program; if not, write to the Free Software */
/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/* */
/* Based on PureData by Miller Puckette and others. */
/* */
/* ---------------------------------------------------------------------------- */
/* this is the original copyright notice: */
/* Copyright (c) 1997-2002 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. */
#include <string.h>
#include "m_pd.h"
#define MATCH_INISIZE 16 /* LATER rethink */
typedef struct _match
{
t_object x_ob;
int x_size; /* as allocated */
int x_patlen; /* as used */
t_atom *x_pattern;
t_atom x_patini[MATCH_INISIZE];
int x_quelen;
t_atom *x_queue;
t_atom x_queini[MATCH_INISIZE];
t_atom *x_queend;
t_atom *x_queptr; /* writing head, post-incremented (oldest-pointing) */
int x_;
} t_match;
static t_class *match_class;
/* a caller must check for nrequested > *sizep */
/* returns actual number of atoms: requested (success)
or a default value of initial size (failure) */
/* the result is guaranteed to be >= min(nrequested, inisize) */
static int match_grow(int nrequested, int *sizep, t_atom **bufp,
int inisize, t_atom *bufini)
{
int newsize = *sizep * 2;
while (newsize < nrequested) newsize *= 2;
if (*bufp == bufini)
*bufp = (t_atom *)getbytes(newsize * sizeof(**bufp));
else
*bufp = (t_atom *)resizebytes(*bufp, *sizep * sizeof(**bufp),
newsize * sizeof(**bufp));
if (*bufp)
*sizep = newsize;
else
{
*bufp = bufini;
nrequested = *sizep = inisize;
}
return (nrequested);
}
static void match_clear(t_match *x)
{
x->x_quelen = 0;
x->x_queptr = x->x_queue;
}
/* x->x_patlen > 0 is assumed */
/* LATER use a lock to disable reentrant calls. I do not see any
purpose of reentering match, but lets CHECKME first... */
static void match_checkin(t_match *x)
{
int i, patlen = x->x_patlen;
t_atom *queptr, *pp, *qp;
if (x->x_queptr >= x->x_queend)
x->x_queptr = x->x_queue;
else x->x_queptr++;
if (x->x_quelen < patlen && ++(x->x_quelen) < patlen)
return;
qp = queptr = x->x_queptr;
for (i = 0, pp = x->x_pattern; i < patlen; i++, pp++)
{
if (pp->a_type == A_FLOAT)
{
if (qp->a_type != A_FLOAT || qp->a_w.w_float != pp->a_w.w_float)
break;
}
else if (pp->a_type == A_SYMBOL)
{
if (qp->a_type != A_SYMBOL || qp->a_w.w_symbol != pp->a_w.w_symbol)
break;
}
else if (pp->a_type == A_NULL)
{
if (qp->a_type == A_FLOAT || qp->a_type == A_SYMBOL)
{
/* instantiating a pattern */
*pp = *qp;
qp->a_type = A_NULL;
}
else break; /* LATER rethink */
}
else break; /* LATER rethink */
if (qp >= x->x_queend)
qp = x->x_queue;
else qp++;
}
if (i == patlen)
{
pp = x->x_pattern;
if (pp->a_type == A_FLOAT)
{
if (patlen == 1)
outlet_float(((t_object *)x)->ob_outlet, pp->a_w.w_float);
else
outlet_list(((t_object *)x)->ob_outlet, &s_list, patlen, pp);
}
else /* assuming A_SYMBOL (see above) */
{
if (pp->a_w.w_symbol == &s_symbol /* bypassing typedmess() */
&& patlen == 2 && pp[1].a_type == A_SYMBOL)
outlet_symbol(((t_object *)x)->ob_outlet, pp[1].a_w.w_symbol);
else
outlet_anything(((t_object *)x)->ob_outlet, pp->a_w.w_symbol,
patlen - 1, pp + 1);
}
/* CHECKED: no implicit clear (resolving overlapping patterns) */
}
/* restoring a pattern */
for (i = 0, pp = x->x_pattern; i < patlen; i++, pp++)
{
if (queptr->a_type == A_NULL)
{
queptr->a_type = pp->a_type;
pp->a_type = A_NULL;
}
if (queptr >= x->x_queend)
queptr = x->x_queue;
else queptr++;
}
}
static void match_float(t_match *x, t_float f)
{
if (x->x_patlen)
{
SETFLOAT(x->x_queptr, f);
match_checkin(x);
}
}
static void match_symbol(t_match *x, t_symbol *s)
{
if (s && s != &s_ && x->x_patlen)
{
SETSYMBOL(x->x_queptr, s);
match_checkin(x);
}
}
/* LATER gpointer */
static void match_list(t_match *x, t_symbol *s, int ac, t_atom *av)
{
while (ac--)
{
if (av->a_type == A_FLOAT) match_float(x, av->a_w.w_float);
else if (av->a_type == A_SYMBOL) match_symbol(x, av->a_w.w_symbol);
av++;
}
}
static void match_anything(t_match *x, t_symbol *s, int ac, t_atom *av)
{
match_symbol(x, s);
match_list(x, 0, ac, av);
}
static void match_set(t_match *x, t_symbol *s, int ac, t_atom *av)
{
if (ac) /* CHECKED */
{
t_atom *pp;
t_symbol *ps_nn;
int newlen = ac * 2;
if (newlen > x->x_size)
{
newlen = match_grow(newlen, &x->x_size, &x->x_pattern,
MATCH_INISIZE * 2, x->x_patini);
if (newlen == MATCH_INISIZE * 2)
{
x->x_queue = x->x_queini;
ac = MATCH_INISIZE;
}
else x->x_queue = x->x_pattern + x->x_size / 2;
}
x->x_patlen = ac;
x->x_queend = x->x_queue + ac - 1;
match_clear(x); /* CHECKED */
memcpy(x->x_pattern, av, ac * sizeof(*x->x_pattern));
pp = x->x_pattern;
ps_nn = gensym("nn");
while (ac--)
{
if (pp->a_type == A_SYMBOL && pp->a_w.w_symbol == ps_nn)
pp->a_type = A_NULL;
pp++;
}
}
}
static void match_free(t_match *x)
{
if (x->x_pattern != x->x_patini)
freebytes(x->x_pattern, 2 * x->x_size * sizeof(*x->x_pattern));
}
static void *match_new(t_symbol *s, int ac, t_atom *av)
{
t_match *x = (t_match *)pd_new(match_class);
x->x_size = MATCH_INISIZE * 2;
x->x_patlen = 0;
x->x_pattern = x->x_patini;
x->x_queue = x->x_queini;
/* x->x_queend is not used unless x->x_patlen > 0,
LATER consider chosing a more defensive way... */
outlet_new((t_object *)x, &s_anything);
match_clear(x);
match_set(x, 0, ac, av);
return (x);
}
#ifndef MAXLIB
void match_setup(void)
{
match_class = class_new(gensym("match"), (t_newmethod)match_new,
(t_method)match_free, sizeof(t_match), 0, A_GIMME, 0);
#else
void maxlib_match_setup(void)
{
match_class = class_new(gensym("maxlib_match"), (t_newmethod)match_new,
(t_method)match_free, sizeof(t_match), 0, A_GIMME, 0);
class_addcreator((t_newmethod)match_new, gensym("match"), A_GIMME, 0);
#endif
class_addfloat(match_class, match_float);
class_addsymbol(match_class, match_symbol);
class_addlist(match_class, match_list);
class_addanything(match_class, match_anything);
class_addmethod(match_class, (t_method)match_set, gensym("set"), A_GIMME, 0);
class_addmethod(match_class, (t_method)match_clear, gensym("clear"), 0);
#ifndef MAXLIB
class_sethelpsymbol(match_class, gensym("help-match.pd"));
#else
class_sethelpsymbol(match_class, gensym("maxlib/help-match.pd"));
#endif
}
--- NEW FILE: lifo.c ---
/* ---------------------------- lifo ------------------------------------------ */
/* */
/* lifo buffer of floats, empties itselfe on every bang (in order of coming in) */
/* Written by Olaf Matthes (olaf.matthes(a)gmx.de) */
/* Get source at http://www.akustische-kunst.org/puredata/maxlib/ */
/* */
/* This program is free software; you can redistribute it and/or */
/* modify it under the terms of the GNU General Public License */
/* as published by the Free Software Foundation; either version 2 */
/* of the License, or (at your option) any later version. */
/* */
/* This program is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
/* GNU General Public License for more details. */
/* */
/* You should have received a copy of the GNU General Public License */
/* along with this program; if not, write to the Free Software */
/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/* */
/* Based on PureData by Miller Puckette and others. */
/* */
/* Fifi-code based St. Rainstick fifo.c for Max, */
/* copyright St. Rainstick, Amsterdam 1995 */
/* */
/* ---------------------------------------------------------------------------- */
#include "m_pd.h"
static char *version = "lifo v0.1, written by Olaf Matthes <olaf.matthes(a)gmx.de>";
typedef struct lifo
{
t_object d_ob;
t_float *getal;
t_int count, end, size, teller;
t_outlet *out;
}t_lifo;
static t_class *lifo_class;
static void lifo_int(t_lifo *x, t_floatarg n)
{
x->getal[x->count] = n;
x->end = x->count;
if (x->teller < x->size) x->teller++;
x->count = (x->count + 1) % x->size;
}
static void lifo_bang(t_lifo *x)
{
if (x->teller > 0){
outlet_float(x->out,x->getal[x->end]);
x->teller--;
x->end = (x->end + x->size - 1) % x->size;
}
}
static void lifo_clear(t_lifo *x)
{
x->teller = 0;
}
static void lifo_free(t_lifo *x)
{
freebytes(x->getal, x->size * sizeof(t_float));
}
static void *lifo_new(t_floatarg n)
{
t_lifo *x = (t_lifo *)pd_new(lifo_class);
if (n<10) n = 10;
x->size = (t_int)n;
x->teller = 0;
x->end = 0;
x->count = 0;
x->getal = (t_float *)getbytes(x->size * sizeof(t_float));
x->out = outlet_new(&x->d_ob, gensym("float"));
return (x);
}
#ifndef MAXLIB
void lifo_setup(void)
{
lifo_class = class_new(gensym("lifo"), (t_newmethod)lifo_new,
(t_method)lifo_free, sizeof(t_lifo), 0, A_DEFFLOAT, 0);
class_addfloat(lifo_class, lifo_int);
class_addbang(lifo_class, lifo_bang);
class_addmethod(lifo_class, (t_method)lifo_clear, gensym("clear"), 0);
class_sethelpsymbol(lifo_class, gensym("help-lifo.pd"));
post(version);
}
#else
void maxlib_lifo_setup(void)
{
lifo_class = class_new(gensym("maxlib_lifo"), (t_newmethod)lifo_new,
(t_method)lifo_free, sizeof(t_lifo), 0, A_DEFFLOAT, 0);
class_addcreator((t_newmethod)lifo_new, gensym("lifo"), A_DEFFLOAT, 0);
class_addfloat(lifo_class, lifo_int);
class_addbang(lifo_class, lifo_bang);
class_addmethod(lifo_class, (t_method)lifo_clear, gensym("clear"), 0);
class_sethelpsymbol(lifo_class, gensym("maxlib/help-lifo.pd"));
}
#endif
--- NEW FILE: velocity.c ---
/* ------------------------- velocity ----------------------------------------- */
/* */
/* Get velocity of input in digits per second. */
/* Written by Olaf Matthes (olaf.matthes(a)gmx.de) */
/* Originally written for Max by Trond Lossius. */
/* Get source at http://www.akustische-kunst.org/puredata/maxlib/ */
/* */
/* This program is free software; you can redistribute it and/or */
/* modify it under the terms of the GNU General Public License */
/* as published by the Free Software Foundation; either version 2 */
/* of the License, or (at your option) any later version. */
/* */
/* This program is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
/* GNU General Public License for more details. */
/* */
/* You should have received a copy of the GNU General Public License */
/* along with this program; if not, write to the Free Software */
/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/* */
/* You should have received a copy of the GNU Lesser General Public */
/* License along with this library; if not, write to the */
/* Free Software Foundation, Inc., 59 Temple Place - Suite 330, */
/* Boston, MA 02111-1307, USA. */
/* */
/* Based on PureData by Miller Puckette and others. */
/* */
/* ---------------------------------------------------------------------------- */
// velocity.c: (1000*(x[n]-x[n-1]))/Æt
// (C) Trond Lossius/BEK 2000
// Last revision: 4/7 2000
//
// Input:
// float
// int (converted to float)
// set (set new value but no output)
// Argument (optional, defaults to 0):
// Initial stored value
// Output:
// float: Velocity as change per second (not ms)
#include "m_pd.h"
static char *version = "velocity v0.1, written by Olaf Matthes <olaf.matthes(a)gmx.de>";
typedef struct velocity
{
t_object x_ob;
t_outlet *x_out;
t_float x_xn1; /* input (floats) */
t_float x_xn;
double x_lasttime;
} t_velocity;
static void velocity_bang(t_velocity *x)
{
double thistime;
t_float vel;
thistime = clock_getlogicaltime();
vel = (1000 * (x->x_xn - x->x_xn1) ) / (clock_gettimesince(x->x_lasttime));
x->x_lasttime = thistime;
outlet_float(x->x_out, vel);
}
static void velocity_float(t_velocity *x, t_floatarg f)
{
x->x_xn1 = x->x_xn;
x->x_xn = f;
velocity_bang(x);
}
static void velocity_free(t_velocity *x)
{
// nothing to do
}
static t_class *velocity_class;
static void *velocity_new(t_floatarg f)
{
t_velocity *x = (t_velocity *)pd_new(velocity_class);
x->x_out = outlet_new(&x->x_ob, gensym("float"));
x->x_lasttime = clock_getlogicaltime();
return (void *)x;
}
#ifndef MAXLIB
void velocity_setup(void)
{
velocity_class = class_new(gensym("velocity"), (t_newmethod)velocity_new,
(t_method)velocity_free, sizeof(t_velocity), 0, A_DEFFLOAT, 0);
#else
void maxlib_velocity_setup(void)
{
velocity_class = class_new(gensym("maxlib_velocity"), (t_newmethod)velocity_new,
(t_method)velocity_free, sizeof(t_velocity), 0, A_DEFFLOAT, 0);
class_addcreator((t_newmethod)velocity_new, gensym("velocity"), A_DEFFLOAT, 0);
#endif
class_addfloat(velocity_class, velocity_float);
class_addbang(velocity_class, velocity_bang);
#ifndef MAXLIB
class_sethelpsymbol(velocity_class, gensym("help-velocity.pd"));
post(version);
#else
class_sethelpsymbol(velocity_class, gensym("maxlib/help-velocity.pd"));
#endif
}
--- NEW FILE: netdist.c ---
/* -------------------------- netdist --------------------------------------- */
/* */
/* Distributes incoming data to a changeable list of netreceive objects. */
/* Uses child thread to connect to clients. Thus needs pd0.35-test17 or later. */
/* Written by Olaf Matthes (olaf.matthes(a)gmx.de) */
/* Get source at http://www.akustische-kunst.org/puredata/maxlib/ */
/* */
/* This program is free software; you can redistribute it and/or */
/* modify it under the terms of the GNU General Public License */
/* as published by the Free Software Foundation; either version 2 */
/* of the License, or (at your option) any later version. */
/* */
/* This program is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
/* GNU General Public License for more details. */
/* */
/* You should have received a copy of the GNU General Public License */
/* along with this program; if not, write to the Free Software */
/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/* */
/* Based on PureData by Miller Puckette and others. */
/* */
/* ---------------------------------------------------------------------------- */
#include "m_pd.h"
#include <sys/types.h>
#include <string.h>
#include <pthread.h>
#ifdef UNIX
#include <sys/socket.h>
#include <sys/errno.h>
#include <netinet/in.h>
#include <netdb.h>
#include <stdio.h>
#include <unistd.h>
#define SOCKET_ERROR -1
#else
#include <winsock.h>
#endif
#define MAX_REC 32
static char *version = "netdist v0.1, written by Olaf Matthes <olaf.matthes(a)gmx.de>";
static t_class *netdist_class;
typedef struct _netdist
{
t_object x_obj;
t_clock *x_clock;
int x_fd[MAX_REC];
char *x_hostname[MAX_REC];
int x_numconnect;
int x_port[MAX_REC];
int x_protocol;
/* multithread stuff */
pthread_t x_threadid; /* id of child thread */
pthread_attr_t x_threadattr; /* attributes of child thread */
} t_netdist;
static void sys_sockerror(char *s)
{
#ifdef NT
int err = WSAGetLastError();
if (err == 10054) return;
#endif
#ifdef UNIX
int err = errno;
#endif
post("%s: %s (%d)\n", s, strerror(err), err);
}
static void sys_closesocket(int fd) {
#ifdef UNIX
close(fd);
#endif
#ifdef NT
closesocket(fd);
#endif
}
static void netdist_tick(t_netdist *x)
{
outlet_float(x->x_obj.ob_outlet, x->x_numconnect + 1);
}
static void *netdist_new(t_floatarg udpflag)
{
int i;
t_netdist *x = (t_netdist *)pd_new(netdist_class);
outlet_new(&x->x_obj, &s_float);
x->x_clock = clock_new(x, (t_method)netdist_tick);
for(i = 0; i < MAX_REC; i++)x->x_fd[i] = -1;
x->x_numconnect = -1;
x->x_protocol = (udpflag != 0 ? SOCK_DGRAM : SOCK_STREAM);
/* prepare child thread */
if(pthread_attr_init(&x->x_threadattr) < 0)
post("netdist: warning: could not prepare child thread" );
if(pthread_attr_setdetachstate(&x->x_threadattr, PTHREAD_CREATE_DETACHED) < 0)
post("netdist: warning: could not prepare child thread" );
return (x);
}
static void *netdist_child_connect(void *w)
{
int i;
t_netdist *x = (t_netdist*) w;
struct sockaddr_in server;
struct hostent *hp;
int sockfd;
int portno;
i = x->x_numconnect + 1;
portno = x->x_port[i];
/* create a socket */
sockfd = socket(AF_INET, x->x_protocol, 0);
#if 0
fprintf(stderr, "send socket %d\n", sockfd);
#endif
if (sockfd < 0)
{
sys_sockerror("socket");
return (x);
}
/* connect socket using hostname provided in command line */
server.sin_family = AF_INET;
hp = gethostbyname(x->x_hostname[i]);
if (hp == 0)
{
post("bad host?\n");
return (x);
}
memcpy((char *)&server.sin_addr, (char *)hp->h_addr, hp->h_length);
/* assign client port number */
server.sin_port = htons((u_short)portno);
post("connecting to port %d", portno);
/* try to connect */
if (connect(sockfd, (struct sockaddr *) &server, sizeof (server)) < 0)
{
sys_sockerror("connecting stream socket");
sys_closesocket(sockfd);
return (x);
}
x->x_fd[i] = sockfd;
/* outlet_float is not threadsafe ! */
// outlet_float(x->x_obj.ob_outlet, 1);
x->x_numconnect++; /* count connection */
/* use callback instead to set outlet */
clock_delay(x->x_clock, 0);
return (x);
}
static void netdist_connect(t_netdist *x, t_symbol *hostname,
t_floatarg fportno)
{
int i;
/* we get hostname and port and pass them on
to the child thread that establishes the connection */
for(i = 0; i <= x->x_numconnect; i++)
{ /* check if we are already connected */
if (hostname->s_name == x->x_hostname[i] && fportno == x->x_port[i])
{
error("netdist_connect: already connected");
return;
}
}
x->x_hostname[x->x_numconnect + 1] = hostname->s_name;
x->x_port[x->x_numconnect + 1] = fportno;
/* start child thread */
if(pthread_create( &x->x_threadid, &x->x_threadattr, netdist_child_connect, x) < 0)
post("netdist: could not create new thread");
}
static void netdist_disconnect(t_netdist *x, t_symbol *hostname, t_floatarg port)
{
int i, j;
for(i = 0; i <= x->x_numconnect; i++)
{
if((hostname->s_name == x->x_hostname[i]) && ((int)port == x->x_port[i]))
{
/* search for connection */
if (x->x_fd[i] >= 0)
{
sys_closesocket(x->x_fd[i]);
x->x_fd[i] = -1;
x->x_numconnect--;
outlet_float(x->x_obj.ob_outlet, x->x_numconnect + 1);
for(j = i; j <= x->x_numconnect; j++)
{
x->x_hostname[j] = x->x_hostname[j + 1];
x->x_port[j] = x->x_port[j + 1];
x->x_fd[j] = x->x_fd[j + 1];
}
}
}
}
}
static void netdist_send(t_netdist *x, t_symbol *s, int argc, t_atom *argv)
{
int i = 0;
for(i = 0; i <= x->x_numconnect; i++)
{
if (x->x_fd[i] >= 0)
{
t_binbuf *b = binbuf_new();
char *buf, *bp;
int length, sent;
t_atom at;
binbuf_add(b, argc, argv);
SETSEMI(&at);
binbuf_add(b, 1, &at);
binbuf_gettext(b, &buf, &length);
for (bp = buf, sent = 0; sent < length;)
{
static double lastwarntime;
static double pleasewarn;
double timebefore = clock_getlogicaltime();
int res = send(x->x_fd[i], buf, length-sent, 0);
double timeafter = clock_getlogicaltime();
int late = (timeafter - timebefore > 0.005);
if (late || pleasewarn)
{
if (timeafter > lastwarntime + 2)
{
post("netdist blocked %d msec",
(int)(1000 * ((timeafter - timebefore) + pleasewarn)));
pleasewarn = 0;
lastwarntime = timeafter;
}
else if (late) pleasewarn += timeafter - timebefore;
}
if (res <= 0)
{
sys_sockerror("netdist");
netdist_disconnect(x, gensym(x->x_hostname[i]), x->x_port[i]);
break;
}
else
{
sent += res;
bp += res;
}
}
t_freebytes(buf, length);
binbuf_free(b);
}
}
if(x->x_numconnect == -1) error("netdist: not connected");
}
/* disconnect all */
static void netdist_clear(t_netdist *x)
{
int i, j, n;
n = x->x_numconnect;
for (i = n; i >= 0; i--)
{
netdist_disconnect(x, gensym(x->x_hostname[i]), x->x_port[i]);
}
}
static void netdist_print(t_netdist *x)
{
int i;
post("netdist: %d connection(s) established:", x->x_numconnect + 1);
for (i = x->x_numconnect; i >= 0; i--)
{
post(" \"%s\", port %d",x->x_hostname[i], x->x_port[i]);
}
}
static void netdist_free(t_netdist *x)
{
netdist_clear(x);
clock_free(x->x_clock);
}
#ifndef MAXLIB
void netdist_setup(void)
{
netdist_class = class_new(gensym("netdist"), (t_newmethod)netdist_new,
(t_method)netdist_free, sizeof(t_netdist), 0, A_DEFFLOAT, 0);
class_addmethod(netdist_class, (t_method)netdist_connect, gensym("connect"), A_SYMBOL, A_FLOAT, 0);
class_addmethod(netdist_class, (t_method)netdist_disconnect, gensym("disconnect"), A_SYMBOL, A_FLOAT, 0);
class_addmethod(netdist_class, (t_method)netdist_send, gensym("send"), A_GIMME, 0);
class_addmethod(netdist_class, (t_method)netdist_clear, gensym("clear"), 0);
class_addmethod(netdist_class, (t_method)netdist_print, gensym("print"), 0);
class_sethelpsymbol(netdist_class, gensym("help-netdist.pd"));
post(version);
}
#else
void maxlib_netdist_setup(void)
{
netdist_class = class_new(gensym("maxlib_netdist"), (t_newmethod)netdist_new,
(t_method)netdist_free, sizeof(t_netdist), 0, A_DEFFLOAT, 0);
class_addcreator((t_newmethod)netdist_new, gensym("netdist"), A_DEFFLOAT, 0);
class_addmethod(netdist_class, (t_method)netdist_connect, gensym("connect"), A_SYMBOL, A_FLOAT, 0);
class_addmethod(netdist_class, (t_method)netdist_disconnect, gensym("disconnect"), A_SYMBOL, A_FLOAT, 0);
class_addmethod(netdist_class, (t_method)netdist_send, gensym("send"), A_GIMME, 0);
class_addmethod(netdist_class, (t_method)netdist_clear, gensym("clear"), 0);
class_addmethod(netdist_class, (t_method)netdist_print, gensym("print"), 0);
class_sethelpsymbol(netdist_class, gensym("maxlib/help-netdist.pd"));
}
#endif
--- NEW FILE: score.c ---
/* ------------------------- score ------------------------------------------ */
/* */
/* Simple score following / orientation. Incoming data gets compared to a */
/* score stored in an array or table. */
/* Written by Olaf Matthes (olaf.matthes(a)gmx.de) */
/* Get source at http://www.akustische-kunst.org/puredata/maxlib/ */
/* */
/* This program is free software; you can redistribute it and/or */
/* modify it under the terms of the GNU General Public License */
/* as published by the Free Software Foundation; either version 2 */
/* of the License, or (at your option) any later version. */
/* */
/* This program is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
/* GNU General Public License for more details. */
/* */
/* You should have received a copy of the GNU General Public License */
/* along with this program; if not, write to the Free Software */
/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/* */
/* Based on PureData by Miller Puckette and others. */
/* */
/* ---------------------------------------------------------------------------- */
#include "m_pd.h"
#define MAX_NOTES 32 /* maximum number of notes that can be stored */
static char *version = "score v0.1, score follower written by Olaf Matthes <olaf.matthes(a)gmx.de>";
typedef struct score
{
t_object x_ob;
t_inlet *x_invelo; /* inlet for velocity */
t_inlet *x_inreset; /* inlet to reset the object */
t_outlet *x_outindex; /* index :: position in given score */
t_outlet *x_outerror; /* indicates lost orientation */
t_symbol *x_sym; /* name of array that contains the score */
t_garray *x_buf; /* the above array itselfe */
t_int x_state; /* indicates state of score following: */
/* running = 1, record = -1, stop = 0 */
t_int x_skipindex; /* max. number of notes to skip */
t_float x_skiptime; /* max time in ms to skip */
t_int x_index; /* position in array / score */
t_int x_lastpitch;
t_int x_error;
t_int x_notecount;
t_int x_pitch;
t_int x_velo;
/* helpers needed to do the calculations */
double x_starttime[MAX_NOTES];
double x_laststarttime;
t_int x_alloctable[MAX_NOTES];
} t_score;
static void score_float(t_score *x, t_floatarg f)
{
/* This is the score following algorhythm:
first, we check if the note we got is in the score. In case
it's not the next note, we'll search 'skipnotes' in advance.
In case that fails we go back 'skipnotes' and check them. As
extra these notes have to be 'younger' than 'skiptime' (to
avoid going back too far in case of slow melodies)
As last resort we check if we probably just got the same not
again (double trigger from keyboard or the like)
*/
t_int velo = x->x_velo; /* get the velocity */
t_garray *b = x->x_buf; /* make local copy of array */
float *tab; /* we'll store notes in here */
int items;
int i, j, n, check;
x->x_pitch = (t_int)f;
x->x_error = 0;
/* check our array */
if (!b)
{
post("score: no array selected!");
x->x_error = 1;
goto output;
}
if (!garray_getfloatarray(b, &items, &tab))
{
post("score: couldn't read from array!");
x->x_error = 1;
goto output;
}
if (x->x_state) /* score follower is running */
{
n = check = x->x_notecount; /* make local copys */
if (x->x_velo != 0) /* store note-on in alloctable */
{
/* store note in alloctable */
x->x_alloctable[n] = (t_int)x->x_pitch;
/* store note-on time */
x->x_starttime[n] = clock_getlogicaltime();
if(++x->x_notecount >= MAX_NOTES)x->x_notecount = 0; /* total number of notes has increased */
} else return; /* we don't care about note-off's */
/* first we try to find a match within the skip area */
/* ( probably looking ahead in the score ) */
for (i = x->x_index + 1; i < (x->x_index + x->x_skipindex + 1); i++)
{
// post("%d: %d -> %d", i, x->x_alloctable[n], (t_int)tab[i]);
if(x->x_alloctable[n] == (t_int)tab[i])
{
if(i - x->x_index != 1) post("score: skipped %d notes!", i - x->x_index - 1);
x->x_alloctable[n] = -1; /* delete note, we've matched it! */
x->x_index = i;
goto output;
}
}
/* then we look back within the boudaries of skiptime */
for (i = x->x_index - 1; i > (x->x_index - x->x_skipindex) - 1; i--)
{
check = n; /* get current notecount */
for (j = 0; j < MAX_NOTES; j++) /* check with every note from our alloctable */
{
if (x->x_alloctable[check] == (t_int)tab[i]) /* this one would fit */
{
/* check the time restrictions */
if (clock_gettimesince(x->x_starttime[check]) < x->x_skiptime)
{
if (i != x->x_index) post("score: skipped %d notes in score!", x->x_index - i);
if (j != 0) post("score: skipped %d notes from input!", j);
post("score: going back by %g milliseconds!", clock_gettimesince(x->x_starttime[check]));
x->x_index = i;
/* new notecount: we assume the notes we skipped are errors made by the */
/* performer. new notes will be added right behind the last valid one */
x->x_notecount = (check++) % MAX_NOTES;
x->x_alloctable[x->x_notecount - 1] = -1; /* delete note since we've matched it */
goto output;
}
else /* ough, too old ! */
{
post("score: matching note is too old! (ignored)");
x->x_alloctable[check] = 0; /* delete note since it's too old */
x->x_error = 1;
goto output; /* stop with first match as all others would be far older */
}
}
if(--check < 0) check = MAX_NOTES - 1; /* decrease counter */
/* as we want to go back in time */
}
}
/* or is it just the same note again ??? (double trigger...) */
if(x->x_pitch == x->x_lastpitch)
{
post("score: repetition! (ignored)");
x->x_alloctable[x->x_notecount - 1] = -1; /* forget this one */
return;
}
/* in case we found nothing: indicate that! */
x->x_error = 1;
post("score: couldn't find any matches !");
x->x_lastpitch = x->x_pitch;
goto output;
}
else return;
output:
/* output index */
outlet_float(x->x_outindex, x->x_index);
/* bang in case of error */
if(x->x_error) outlet_bang(x->x_outerror);
}
static void score_ft1(t_score *x, t_floatarg f)
{
x->x_velo = (t_int)f;
}
/* start following the previoisly recorded score */
static void score_start(t_score *x, t_symbol *s, t_int argc, t_atom* argv)
{
x->x_index = (t_int)atom_getfloatarg(0, argc, argv);
if(x->x_index > 0)
{
post("score: starting at note %d", x->x_index);
}
else post("score: start following");
x->x_index--; /* because our array starts with 0 */
x->x_state = 1;
}
/* resume following the previoisly recorded score */
static void score_resume(t_score *x)
{
x->x_state = 1;
post("score: resume following");
}
/* stop following the previoisly recorded score */
static void score_stop(t_score *x)
{
x->x_state = 0;
post("score: stop following");
}
/* choose the array that holds the score */
void score_set(t_score *x, t_symbol *s)
{
t_garray *b;
x->x_sym = s;
if ((b = (t_garray *)pd_findbyclass(s, garray_class)))
{
post("score: array set to \"%s\"", s->s_name);
x->x_buf = b;
} else {
post("score: no array \"%s\" (error %d)", s->s_name, b);
x->x_buf = 0;
}
}
static void score_reset(t_score *x)
{
int i;
x->x_state = 0; /* don't follow */
x->x_error = 0;
x->x_index = -1;
x->x_notecount = 0;
x->x_lastpitch = 0;
for(i = 0; i < MAX_NOTES; i++)x->x_alloctable[i] = -1;
post("score: reset");
}
static void score_free(t_score *x)
{
// nothing to do
}
static t_class *score_class;
static void *score_new(t_symbol *s, t_floatarg fskipindex, t_floatarg fskiptime)
{
int i;
t_score *x = (t_score *)pd_new(score_class);
x->x_invelo = inlet_new(&x->x_ob, &x->x_ob.ob_pd, gensym("float"), gensym("ft1"));
x->x_inreset = inlet_new(&x->x_ob, &x->x_ob.ob_pd, gensym("bang"), gensym("reset"));
x->x_outindex = outlet_new(&x->x_ob, gensym("float"));
x->x_outerror = outlet_new(&x->x_ob, gensym("float"));
x->x_sym = s; /* get name of array */
score_set(x,x->x_sym); /* set array */
if(!fskipindex)fskipindex = 2;
if(!fskiptime)fskiptime = 300.0;
x->x_skipindex = (t_int)fskipindex;
x->x_skiptime = (t_float)fskiptime;
post("score: skipindex set to %d, skiptime set to %g milliseconds", x->x_skipindex, x->x_skiptime);
x->x_state = 0; /* don't follow */
x->x_error = 0;
x->x_index = -1;
x->x_notecount = 0;
x->x_pitch = x->x_lastpitch = -1;
for(i = 0; i < MAX_NOTES; i++)x->x_alloctable[i] = -1;
return (void *)x;
}
#ifndef MAXLIB
void score_setup(void)
{
score_class = class_new(gensym("score"), (t_newmethod)score_new,
(t_method)score_free, sizeof(t_score), 0, A_SYMBOL, A_DEFFLOAT, A_DEFFLOAT, 0);
class_addmethod(score_class, (t_method)score_reset, gensym("reset"), 0);
class_addmethod(score_class, (t_method)score_resume, gensym("resume"), 0);
class_addmethod(score_class, (t_method)score_start, gensym("start"), A_GIMME, 0);
class_addmethod(score_class, (t_method)score_stop, gensym("stop"), 0);
class_addmethod(score_class, (t_method)score_ft1, gensym("ft1"), A_FLOAT, 0);
class_addmethod(score_class, (t_method)score_reset, gensym("reset"), A_GIMME, 0);
class_addmethod(score_class, (t_method)score_set, gensym("set"), A_SYMBOL, 0);
class_addfloat(score_class, score_float);
class_sethelpsymbol(score_class, gensym("help-score.pd"));
post(version);
}
#else
void maxlib_score_setup(void)
{
score_class = class_new(gensym("maxlib_score"), (t_newmethod)score_new,
(t_method)score_free, sizeof(t_score), 0, A_SYMBOL, A_DEFFLOAT, A_DEFFLOAT, 0);
class_addcreator((t_newmethod)score_new, gensym("score"), A_SYMBOL, A_DEFFLOAT, A_DEFFLOAT, 0);
class_addmethod(score_class, (t_method)score_reset, gensym("reset"), 0);
class_addmethod(score_class, (t_method)score_resume, gensym("resume"), 0);
class_addmethod(score_class, (t_method)score_start, gensym("start"), A_GIMME, 0);
class_addmethod(score_class, (t_method)score_stop, gensym("stop"), 0);
class_addmethod(score_class, (t_method)score_ft1, gensym("ft1"), A_FLOAT, 0);
class_addmethod(score_class, (t_method)score_reset, gensym("reset"), A_GIMME, 0);
class_addmethod(score_class, (t_method)score_set, gensym("set"), A_SYMBOL, 0);
class_addfloat(score_class, score_float);
class_sethelpsymbol(score_class, gensym("maxlib/help-score.pd"));
}
#endif
--- NEW FILE: nroute.c ---
/* ------------------------- nroute ------------------------------------------ */
/* */
/* Route input according to Nth element. */
/* Written by Olaf Matthes <olaf.matthes(a)gmx.de> */
/* Based on code found on the web. */
/* Get source at http://www.akustische-kunst.org/puredata/maxlib/ */
/* */
/* This program is free software; you can redistribute it and/or */
/* modify it under the terms of the GNU General Public License */
/* as published by the Free Software Foundation; either version 2 */
/* of the License, or (at your option) any later version. */
/* */
/* This program is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
/* GNU General Public License for more details. */
/* */
/* You should have received a copy of the GNU General Public License */
/* along with this program; if not, write to the Free Software */
/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/* */
/* Based on PureData by Miller Puckette and others. */
/* */
/* ---------------------------------------------------------------------------- */
/*
inlet 1: anything to be routed
inlet 2: anything to be matched to
inlet 3: position to match
out 1: input if match found
out 2: input if match not found
*/
#include "m_pd.h"
static char *version = "nroute v0.1, written by Olaf Matthes <olaf.matthes(a)gmx.de>";
typedef struct nroute
{
t_object x_obj;
t_outlet *out1;
t_outlet *out2;
t_int pos;
t_atom match;
} t_nroute;
typedef struct proxy
{
t_object obj;
t_int index; /* number of proxy inlet(s) */
t_nroute *x; /* we'll put the other struct in here */
} t_proxy;
/* this is the routine that actually does the routing / matching */
/* it get's called by all other routines that get any input and */
/* even handles the second (proxy) inlet ! */
static void nroute_any(t_nroute *x, t_symbol *s, int argc, t_atom *argv)
{
if(s)
{
if (x->pos == 1 && x->match.a_type == A_SYMBOL && x->match.a_w.w_symbol == s)
outlet_anything (x->out1,s,argc,argv);
else if (x->pos > 1 && x->pos <= argc + 1 &&
argv[x->pos-2].a_type == x->match.a_type &&
argv[x->pos-2].a_w.w_float == x->match.a_w.w_float)
outlet_anything (x->out1,s,argc,argv);
else outlet_anything (x->out2,s,argc,argv);
}
else
{
if (x->pos > 0 && x->pos <= argc &&
argv[x->pos-1].a_type == x->match.a_type &&
argv[x->pos-1].a_w.w_float == x->match.a_w.w_float)
outlet_list (x->out1,0,argc,argv);
else outlet_list (x->out2,0,argc,argv);
}
}
static void nroute_float(t_nroute *x, float f)
{
t_atom a;
SETFLOAT (&a,f);
nroute_any(x,0,1,&a);
}
static void nroute_list(t_nroute *x, t_symbol *s, int argc, t_atom *argv)
{
nroute_any(x,0,argc,argv);
}
static void nroute_setmatch(t_proxy *p, t_symbol *s, int argc, t_atom *argv)
{
t_nroute *x = (t_nroute *)(p->x);
if(argc == 0) /* have to match a symbol */
{
x->match.a_type = A_SYMBOL;
x->match.a_w.w_symbol = s;
}
else /* got a float */
{
if(argc > 1)
{
post("nroute: middle inlet accepts only (float,symbol) for match");
return;
}
x->match.a_type = A_FLOAT;
x->match.a_w.w_float = argv[0].a_w.w_float;
}
}
static void nroute_setpos(t_nroute *x, t_floatarg f)
{
x->pos = (t_int)f;
}
static t_class *nroute_class;
static t_class *proxy_class;
static void *nroute_new(t_symbol *s, int argc, t_atom *argv)
{
t_nroute *x = (t_nroute *)pd_new(nroute_class);
t_proxy *inlet = (t_proxy *)pd_new(proxy_class); /* for the proxy inlet */
inlet->x = x; /* make x visible to the proxy inlets */
x->pos = 1;
x->match.a_type = A_NULL;
if (argc > 2) { error ("nroute: extra arguments"); return 0; }
if (argc > 1) {
if (argv[1].a_type == A_FLOAT) x->pos = argv[1].a_w.w_float;
else { post ("nroute: second argument must be (int) position"); return 0; }
}
if (argc > 0) {
x->match.a_type = argv[0].a_type;
x->match.a_w.w_float = argv[0].a_w.w_float;
}
inlet->index = 0; /* we are going to create a proxy inlet no. 0 */
/* it belongs to the object t_nroute but the destination is t_proxy */
inlet_new(&x->x_obj, &inlet->obj.ob_pd, 0,0);
/* and now a 'normal' third inlet */
inlet_new(&x->x_obj, &x->x_obj.ob_pd, gensym("float"), gensym("right"));
x->out1 = outlet_new(&x->x_obj, gensym("list"));
x->out2 = outlet_new(&x->x_obj, gensym("list"));
return (x);
}
#ifndef MAXLIB
void nroute_setup(void)
{
/* the object's class: */
nroute_class = class_new(gensym("nroute"), (t_newmethod)nroute_new,
0, sizeof(t_nroute), 0, A_GIMME, 0);
#else
void maxlib_nroute_setup(void)
{
/* the object's class: */
nroute_class = class_new(gensym("maxlib_nroute"), (t_newmethod)nroute_new,
0, sizeof(t_nroute), 0, A_GIMME, 0);
class_addcreator((t_newmethod)nroute_new, gensym("nroute"), A_GIMME, 0);
#endif
/* a class for the proxy inlet: */
proxy_class = class_new(gensym("maxlib_nroute_proxy"), NULL, NULL, sizeof(t_proxy),
CLASS_PD|CLASS_NOINLET, A_NULL);
class_addmethod(nroute_class, (t_method)nroute_setpos, gensym("right"), A_FLOAT, 0);
class_addfloat(nroute_class, nroute_float);
class_addlist(nroute_class, nroute_list);
class_addanything(nroute_class, nroute_any);
class_addanything(proxy_class, nroute_setmatch);
#ifndef MAXLIB
class_sethelpsymbol(nroute_class, gensym("help-nroute.pd"));
post(version);
#else
class_sethelpsymbol(nroute_class, gensym("maxlib/help-nroute.pd"));
#endif
}
--- NEW FILE: subst.c ---
/* ------------------------- subst ------------------------------------------ */
/* */
/* Performs 'self-similar' substitution of a given list of values. */
/* Written by Olaf Matthes <olaf.matthes(a)gmx.de> */
/* Get source at http://www.akustische-kunst.org/puredata/maxlib/ */
/* */
/* This program is free software; you can redistribute it and/or */
/* modify it under the terms of the GNU General Public License */
/* as published by the Free Software Foundation; either version 2 */
/* of the License, or (at your option) any later version. */
/* */
/* This program is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
/* GNU General Public License for more details. */
/* */
/* You should have received a copy of the GNU General Public License */
/* along with this program; if not, write to the Free Software */
/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/* */
/* Based on PureData by Miller Puckette and others. */
/* */
/* ---------------------------------------------------------------------------- */
#include "m_pd.h"
static char *version = "subst v0.1, self-similar substitution of rows (list or array)\n"
" written by Olaf Matthes <olaf.matthes(a)gmx.de>";
#undef DEBUG
//#define DEBUG
#define MAXSIZE 1024
#include <stdio.h>
#include <stdlib.h>
//
// Maxlife object data structure
//
typedef struct subst
{
t_object x_obj; // must begin every object
t_outlet *x_outlist; // outlet for the processed list
t_outlet *x_outlength;
t_atom x_row[MAXSIZE]; // row of values to get processed
t_int x_length; // length of row
t_int x_order; // size of the CA field/world
t_symbol *x_array; // name of array that holds the data
t_garray *x_buf; // content of that array
} t_subst;
//
// Function prototypes for our methods and functions
//
static t_class *subst_class; // global variable that points to the Maxlife class
//
// get the sum of intervals from no a to no b
// Parameters: the row, it's length, intv a, intev b
//
static int sum_intv(t_atom *argv, int argc, int a, int b)
{
int i;
int summe = 0; // sum of intervals
if(a==b)
return(0); // same index
if(atom_getintarg(a, argc, argv) == atom_getintarg(b, argc, argv))
return(0); // same value
for(i=a;i<b;i++) // for all values from a to b....
{
if(atom_getintarg(i + 1, argc, argv) > atom_getintarg(i, argc, argv)) // positive intv.
{
summe += ((atom_getintarg(i + 1, argc, argv) - atom_getintarg(i, argc, argv)) % 12);
}
else // negative interval
{
summe -= ((atom_getintarg(i + 1, argc, argv) - atom_getintarg(i, argc, argv)) % 12);
}
}
return(summe);
}
//----- Anzahl Partialreihen mit Interval d -------------------------------
static int no_part(t_atom *argv, int argc, int a, int b, int d) // nn
{
int i,j,r = 0;
if(a = b)return(0);
for(i = a; i < b; i++)
{
for(j=a+1;j<b;j++)
{
if(sum_intv(argv, argc, i, j) == d)
r++;
}
}
return(r);
}
//----- n-te Partialreihe der Länge l mit Interval d -----------------------
static int n_part_intv(t_atom *argv, int argc, int a, int b, int l, int d, int n) // nn
{
int i,j, r = 0;
if(n > no_part(argv, argc, a, b, d))
return(-1);
for(i = 1; i = (b - a); i++)
{
for(j = 1; j = b; j++)
{
if(sum_intv(argv, argc, i, j) == d)
r++;
}
}
return(r);
}
//----- Test, ob Partialreihe der Ordnung o mit Interval d existiert ----------
static int check_part_intv(t_atom *argv, int argc, int o, int d)
{
int z;
for(z = 0; z < argc - o; z++)
{
if(sum_intv(argv, argc, z, z + o) == d)
return(z); // Abstand von Reihenanfang
}
return(-1);
}
static int my_random(int range) {
int ret = rand();
ret = ret % range; // limit to desired output range
return(ret);
}
//
// the substitution algorhythm
//
static int subst_calc(t_subst *x, int n)
{
int i,j,k,l,o = x->x_order;
int s = -1;
int intv;
t_atom newrow[MAXSIZE];
t_garray *A = x->x_buf;
int npoints;
t_float *vec;
if(x->x_length <= 1)
{
post("subst: need some data first!");
return(-1);
}
srand((unsigned int)clock_getlogicaltime());
if(n == -1) // no interval given: choose one by chance
{
do
{
n = my_random(x->x_length - 1); // choose interval
intv = sum_intv(x->x_row, x->x_length, n, n + 1); // size of this interval
}
while(intv == 0); // ...until we found one that is not 0!
}
else intv = sum_intv(x->x_row, x->x_length, n, n + 1);
#ifdef DEBUG
post("subst: substitution of %dth interval (%d halftones)", n+1, intv);
#endif
/* for-Schleife für möglichst lange Substitutionen
for(j=anzahlReihe(alteReihe);j>2;j--) */
for(j = x->x_order; j < x->x_length; j++) // prefer lower orders (min. 2)
{ // search for possible order...
s = check_part_intv(x->x_row, x->x_length, j, intv);
if(s != -1) // check if there is a partial row with the interval we want
{
o = j; // save actual order, might be larger then x->x_order
break; // ... do it!
}
if(o == j)break; // found one
}
for(i = 0; i < x->x_length; i++)
{
if(i <= n) // just copy values before substitution
{
newrow[i] = x->x_row[i];
}
if((i == n) && (s != -1)) // now substitute
{
for(k=1;k<o;k++) // well get order - 1 new values...
{
SETFLOAT(newrow + (i + k), (atom_getintarg((i + k - 1), 1024, newrow)
+ sum_intv(x->x_row, x->x_length, s+k-1, s+k)));
#ifdef DEBUG
post("subst: new interval[%d]: %d ", k, sum_intv(x->x_row, x->x_length, s+k-1, s+k));
#endif
}
post("subst: replaced interval %d (%d halftones) with %d new intervals", n, intv, o);
}
else if((i == n) && (s == -1)) // not partial row found
{
o = 1; // order is 1 -> now substitution
newrow[i] = x->x_row[i]; // copy the next value of the row
post("subst: coundn't find any partial rows to fit in!");
}
if(i>n) // behind substitution
{
newrow[i+(o-1)] = x->x_row[i]; // copy rest or row
}
}
// copy stuff back...
x->x_length = l = x->x_length + o - 1;
for(i = 0; i < x->x_length; i++)
x->x_row[i] = newrow[i];
// write to array
if(x->x_array)if (!(A = (t_garray *)pd_findbyclass(x->x_array, garray_class)))
error("subst: %s: no such array", x->x_array->s_name);
else if (!garray_getfloatarray(A, &npoints, &vec))
error("subst: %s: bad template ", x->x_array->s_name);
else
{
i = 0;
if (l >= npoints) // keep end of array
{
while(npoints--)
{
*vec++ = atom_getfloat(x->x_row + i);
i++;
}
}
else // update
{
npoints -= l;
while (l--)
{
*vec++ = atom_getfloat(x->x_row + i);
i++;
}
while (npoints--) *vec++ = 0;
}
garray_redraw(A);
}
// output stuff
outlet_float(x->x_outlength, x->x_length);
outlet_list(x->x_outlist, NULL, x->x_length, x->x_row);
return(0);
}
static void subst_list(t_subst *x, t_symbol *s, int argc, t_atom *argv)
{
t_garray *b = x->x_buf; /* make local copy of array */
float *tab; /* we'll store notes in here */
int items;
int i;
for(i = 0; i < argc; i++)
{
x->x_row[i] = argv[i]; // just copy input
}
x->x_length = argc;
}
//
// choose the array that holds the processed row (output!!)
//
void subst_set(t_subst *x, t_symbol *s)
{
t_garray *b;
x->x_array = s;
if ((b = (t_garray *)pd_findbyclass(s, garray_class)))
{
post("subst: array set to \"%s\"", s->s_name);
x->x_buf = b;
} else {
post("subst: no array \"%s\" (error %d)", s->s_name, b);
x->x_buf = 0;
}
}
//
// load row from array (input!!)
//
static void subst_load(t_subst *x, t_symbol *s)
{
t_garray *b; /* make local copy of array */
t_float *tab; /* the content itselfe */
int items, i;
if ((b = (t_garray *)pd_findbyclass(s, garray_class)))
{
post("subst: array set to \"%s\"", s->s_name);
} else {
post("subst: no array \"%s\" (error %d)", s->s_name, b);
return;
}
// read from our array
if (!garray_getfloatarray(b, &items, &tab))
{
post("subst: couldn't read from array!");
return;
}
for(i = 0; i < items; i++)
{
SETFLOAT(x->x_row + i, tab[i]); // copy array into x->x_row
}
x->x_length = items;
post("subst: loaded %d values from array \"%s\"", items, s->s_name);
}
//
// substitute an interval choosen by chance
//
static void subst_bang(t_subst *x)
{
subst_calc(x, -1);
}
//
// substitute the Nth interval
//
static void subst_intv(t_subst *x, t_floatarg f)
{
int i = (int)f;
if(i > x->x_length) i = x->x_length;
subst_calc(x, i);
}
//
// set the minimum order of substitution
//
static void subst_set_order(t_subst *x, t_floatarg f)
{
x->x_order = (t_int)f;
if(x->x_order < 2)x->x_order = 2;
post("subst: set order to %d", x->x_order);
}
//
// method to print out: but what?
//
static void subst_display(t_subst *x)
{
}
//
// function to create an instance of the subst class
//
static void *subst_new(t_symbol *s, int argc, t_atom *argv)
{
long i;
t_symbol *sym;
t_subst *x = (t_subst *)pd_new(subst_class);
// read in order...
x->x_order = 3;
if(argc == 1)
{
x->x_order = atom_getintarg(0, argc, argv);
}
else if(argc == 2)
{
sym = atom_getsymbolarg(0, argc, argv);
x->x_order = atom_getintarg(1, argc, argv);
subst_set(x, sym);
}
// create outlets
x->x_outlist = outlet_new(&x->x_obj, gensym("list"));
x->x_outlength = outlet_new(&x->x_obj, gensym("float"));
return(x); // always return a copy of the created object
}
static void subst_free(t_subst *x)
{
/* nothing to do */
}
#ifndef MAXLIB
void subst_setup(void)
{
subst_class = class_new(gensym("subst"), (t_newmethod)subst_new,
(t_method)subst_free, sizeof(t_subst), 0, A_GIMME, 0);
class_addmethod(subst_class, (t_method)subst_set_order, gensym("order"), A_FLOAT, 0);
class_addmethod(subst_class, (t_method)subst_intv, gensym("interval"), A_FLOAT, 0);
class_addmethod(subst_class, (t_method)subst_set, gensym("set"), A_SYMBOL, 0);
class_addmethod(subst_class, (t_method)subst_load, gensym("load"), A_SYMBOL, 0);
class_addmethod(subst_class, (t_method)subst_display, gensym("display"), 0);
class_addlist(subst_class, subst_list);
class_addbang(subst_class, subst_bang);
class_sethelpsymbol(subst_class, gensym("help-subst.pd"));
post(version);
}
#else
void maxlib_subst_setup(void)
{
subst_class = class_new(gensym("maxlib_subst"), (t_newmethod)subst_new,
(t_method)subst_free, sizeof(t_subst), 0, A_GIMME, 0);
class_addcreator((t_newmethod)subst_new, gensym("subst"), A_GIMME, 0);
class_addmethod(subst_class, (t_method)subst_set_order, gensym("order"), A_FLOAT, 0);
class_addmethod(subst_class, (t_method)subst_intv, gensym("interval"), A_FLOAT, 0);
class_addmethod(subst_class, (t_method)subst_set, gensym("set"), A_SYMBOL, 0);
class_addmethod(subst_class, (t_method)subst_load, gensym("load"), A_SYMBOL, 0);
class_addmethod(subst_class, (t_method)subst_display, gensym("display"), 0);
class_addlist(subst_class, subst_list);
class_addbang(subst_class, subst_bang);
class_sethelpsymbol(subst_class, gensym("maxlib/help-subst.pd"));
}
#endif
--- NEW FILE: weibull.c ---
/* ---------------------------- rand_weibull ---------------------------------- */
/* */
/* rand_weibull generates a weibull distributed random variable. */
/* Written by Olaf Matthes (olaf.matthes(a)gmx.de) */
/* Based on code found in Dodge/Jerse "Computer Music" */
/* Get source at http://www.akustische-kunst.org/puredata/maxlib/ */
/* */
/* This program is free software; you can redistribute it and/or */
/* modify it under the terms of the GNU General Public License */
/* as published by the Free Software Foundation; either version 2 */
/* of the License, or (at your option) any later version. */
/* */
/* This program is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
/* GNU General Public License for more details. */
/* */
/* You should have received a copy of the GNU General Public License */
/* along with this program; if not, write to the Free Software */
/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/* */
/* Based on PureData by Miller Puckette and others. */
/* */
/* ---------------------------------------------------------------------------- */
#include "m_pd.h"
#include <stdlib.h>
#include <time.h>
#include <math.h>
#define fran() (t_float)rand()/(t_float)RAND_MAX
#ifndef M_PI
#define M_PI 3.1415927
#endif
static char *version = "weibull v0.1, generates a weibull distributed random variable\n"
" written by Olaf Matthes <olaf.matthes(a)gmx.de>";
/* -------------------------- rand_weibull ------------------------------ */
static t_class *rand_weibull_class;
typedef struct _rand_weibull
{
t_object x_obj;
t_float x_s;
t_float x_t;
} t_rand_weibull;
static void *rand_weibull_new(t_floatarg s, t_floatarg t)
{
t_rand_weibull *x = (t_rand_weibull *)pd_new(rand_weibull_class);
srand( (unsigned)time( NULL ) );
floatinlet_new(&x->x_obj, &x->x_s);
floatinlet_new(&x->x_obj, &x->x_t);
outlet_new(&x->x_obj, &s_float);
x->x_s = s;
x->x_t = t;
return (x);
}
static void rand_weibull_bang(t_rand_weibull *x)
{
t_float u, a, t, tinv;
t = (x->x_t <= 0 ? 0.0001 : x->x_t);
tinv = 1/t;
do
{
u = fran();
}
while(u == 0 || u == 1);
a = 1/(1 - u);
outlet_float(x->x_obj.ob_outlet, x->x_s*pow(log(a), tinv));
}
#ifndef MAXLIB
void weibull_setup(void)
{
rand_weibull_class = class_new(gensym("weibull"), (t_newmethod)rand_weibull_new, 0,
sizeof(t_rand_weibull), 0, A_DEFFLOAT, A_DEFFLOAT, 0);
#else
void maxlib_weibull_setup(void)
{
rand_weibull_class = class_new(gensym("maxlib_weibull"), (t_newmethod)rand_weibull_new, 0,
sizeof(t_rand_weibull), 0, A_DEFFLOAT, A_DEFFLOAT, 0);
class_addcreator((t_newmethod)rand_weibull_new, gensym("weibull"), A_DEFFLOAT, A_DEFFLOAT, 0);
#endif
class_addbang(rand_weibull_class, rand_weibull_bang);
#ifndef MAXLIB
class_sethelpsymbol(rand_weibull_class, gensym("help-weibull.pd"));
post(version);
#else
class_sethelpsymbol(rand_weibull_class, gensym("maxlib/help-weibull.pd"));
#endif
}
--- NEW FILE: step.c ---
/* -------------------------- step ------------------------------------------ */
/* */
/* Step to a new value in N milliseconds (similar to line). */
/* Written by Olaf Matthes (olaf.matthes(a)gmx.de) */
/* Get source at http://www.akustische-kunst.org/puredata/maxlib/ */
/* */
/* This program is free software; you can redistribute it and/or */
/* modify it under the terms of the GNU General Public License */
/* as published by the Free Software Foundation; either version 2 */
/* of the License, or (at your option) any later version. */
/* */
/* This program is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
/* GNU General Public License for more details. */
/* */
/* You should have received a copy of the GNU General Public License */
/* along with this program; if not, write to the Free Software */
/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/* */
/* Based on PureData by Miller Puckette and others. */
/* */
/* ---------------------------------------------------------------------------- */
#include "m_pd.h"
/* -------------------------- step ------------------------------ */
static char *version = "step v0.1, written by Olaf Matthes <olaf.matthes(a)gmx.de>";
static t_class *step_class;
typedef struct _step
{
t_object x_obj;
t_clock *x_clock;
double x_targettime;
t_float x_targetval;
double x_prevtime;
t_float x_setval;
int x_gotinlet;
t_float x_grain; /* time interval for output */
t_float x_step; /* step size for output */
t_float x_steptime; /* length for one step */
t_int x_stepcall;
double x_1overtimediff;
double x_in1val;
} t_step;
static void step_tick(t_step *x)
{
t_float outvalue;
double timenow = clock_getsystime();
double msectogo = - clock_gettimesince(x->x_targettime);
if (msectogo < 1E-9)
{
outlet_float(x->x_obj.ob_outlet, x->x_targetval);
}
else
{
if(x->x_setval < x->x_targetval)
{ /* count upwards */
outvalue = x->x_setval + x->x_stepcall * x->x_step;
}
else
{ /* count downwards */
outvalue = x->x_setval - x->x_stepcall * x->x_step;
}
outlet_float(x->x_obj.ob_outlet, outvalue);
clock_delay(x->x_clock, (x->x_steptime > msectogo ? msectogo : x->x_steptime));
}
x->x_stepcall++;
}
static void step_float(t_step *x, t_float f)
{
double timenow = clock_getsystime();
if (x->x_gotinlet && x->x_in1val > 0 && x->x_step != 0 && f != x->x_setval)
{
if (timenow > x->x_targettime) x->x_setval = x->x_targetval;
else x->x_setval = x->x_setval + x->x_1overtimediff *
(timenow - x->x_prevtime)
* (x->x_targetval - x->x_setval);
x->x_prevtime = timenow;
x->x_targetval = f; /* where to end */
x->x_stepcall = 0;
/* how long does it take ? */
x->x_targettime = clock_getsystimeafter(x->x_in1val);
if(x->x_setval < x->x_targetval)
{
x->x_steptime = x->x_in1val / (int)((x->x_targetval - x->x_setval) / x->x_step);
}
else
{
x->x_steptime = x->x_in1val / (int)((x->x_setval - x->x_targetval) / x->x_step);
}
// post("steptime %g", x->x_steptime);
step_tick(x);
x->x_gotinlet = 0;
x->x_1overtimediff = 1./ (x->x_targettime - timenow);
/* call tick function */
clock_delay(x->x_clock, x->x_steptime);
}
else
{
clock_unset(x->x_clock);
x->x_targetval = x->x_setval = f;
outlet_float(x->x_obj.ob_outlet, f);
}
x->x_gotinlet = 0;
}
static void step_ft1(t_step *x, t_floatarg g)
{
x->x_in1val = g;
x->x_gotinlet = 1;
}
static void step_ft2(t_step *x, t_floatarg g)
{
if (g <= 0) g = 1;
x->x_step = g;
x->x_gotinlet = 1;
}
static void step_stop(t_step *x)
{
x->x_targetval = x->x_setval;
clock_unset(x->x_clock);
}
static void step_free(t_step *x)
{
clock_free(x->x_clock);
}
static void *step_new(t_floatarg f, t_floatarg step, t_floatarg grain)
{
t_step *x = (t_step *)pd_new(step_class);
x->x_targetval = x->x_setval = f;
x->x_gotinlet = 0;
x->x_1overtimediff = 1;
x->x_clock = clock_new(x, (t_method)step_tick);
x->x_targettime = x->x_prevtime = clock_getsystime();
if (grain <= 0) grain = 20;
x->x_grain = grain;
if (step <= 0) step = 1;
x->x_step = step;
outlet_new(&x->x_obj, gensym("float"));
inlet_new(&x->x_obj, &x->x_obj.ob_pd, gensym("float"), gensym("ft1"));
inlet_new(&x->x_obj, &x->x_obj.ob_pd, gensym("float"), gensym("ft2"));
return (x);
}
#ifndef MAXLIB
void step_setup(void)
{
step_class = class_new(gensym("step"), (t_newmethod)step_new,
(t_method)step_free, sizeof(t_step), 0, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0);
class_addmethod(step_class, (t_method)step_ft1, gensym("ft1"), A_FLOAT, 0);
class_addmethod(step_class, (t_method)step_ft2, gensym("ft2"), A_FLOAT, 0);
class_addmethod(step_class, (t_method)step_stop, gensym("stop"), 0);
class_addfloat(step_class, (t_method)step_float);
class_sethelpsymbol(step_class, gensym("help-step.pd"));
post(version);
}
#else
void maxlib_step_setup(void)
{
step_class = class_new(gensym("maxlib_step"), (t_newmethod)step_new,
(t_method)step_free, sizeof(t_step), 0, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0);
class_addcreator((t_newmethod)step_new, gensym("step"), A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0);
class_addmethod(step_class, (t_method)step_ft1, gensym("ft1"), A_FLOAT, 0);
class_addmethod(step_class, (t_method)step_ft2, gensym("ft2"), A_FLOAT, 0);
class_addmethod(step_class, (t_method)step_stop, gensym("stop"), 0);
class_addfloat(step_class, (t_method)step_float);
class_sethelpsymbol(step_class, gensym("maxlib/help-step.pd"));
}
#endif
--- NEW FILE: pulse.c ---
/* --------------------------- pong ------------------------------------------ */
/* */
/* A more accurate replacement for the tempo object. */
/* Written by Olaf Matthes <olaf.matthes(a)gmx.de> */
/* Based on pulse for Max written by James McCartney. */
/* Get source at http://www.akustische-kunst.org/puredata/maxlib/ */
/* */
/* This program is free software; you can redistribute it and/or */
/* modify it under the terms of the GNU General Public License */
/* as published by the Free Software Foundation; either version 2 */
/* of the License, or (at your option) any later version. */
/* */
/* This program is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
/* GNU General Public License for more details. */
/* */
/* You should have received a copy of the GNU General Public License */
/* along with this program; if not, write to the Free Software */
/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/* */
/* Based on PureData by Miller Puckette and others. */
/* */
/* ---------------------------------------------------------------------------- */
/* pulse.c ---- a more accurate replacement for the tempo object */
/* updated for CW 68K / PPC summer 96 -RD */
/* written for Max by James McCartney */
#include "m_pd.h"
#include <stdio.h>
static char *version = "pulse v0.1b, written by James McCartney for Max <james(a)clyde.as.utexas.edu>\n"
" ported to Pd by Olaf Matthes <olaf.matthes(a)gmx.de>";
/* Pulse object data structure */
typedef struct pulse
{
t_object p_ob;
t_clock *p_clock;
t_outlet *p_out1; /* outlet */
t_outlet *p_out2; /* outlet */
t_int p_onoff, p_changenumer, p_changedenom;
t_int p_tempo, p_durnumer, p_durdenom, p_maxbeats, p_count;
double p_starttime, p_endtime, p_startremain, p_endremain, p_mspbquotient;
t_int p_newdurnumer, p_newdurdenom;
t_int p_mspbnumer, p_mspbdenom, p_mspbremainder;
} Pulse;
static t_class *pulse_class;
static void durcalc(Pulse *x)
{
/* recalc duration */
x->p_mspbnumer = 240000 * x->p_durnumer;
if (x->p_tempo * x->p_durdenom != 0) /* bug fix by Frank Barknecht */
x->p_mspbdenom = x->p_tempo * x->p_durdenom;
x->p_mspbquotient = x->p_mspbnumer / x->p_mspbdenom;
x->p_mspbremainder = x->p_mspbnumer % x->p_mspbdenom;
if (x->p_mspbquotient < 5) {
x->p_mspbquotient = 5;
x->p_mspbremainder = 0;
}
}
static void pulse_onoff(Pulse *x, t_floatarg f)
{
int i = (int)f;
if (i && !x->p_onoff) {
x->p_onoff = 1;
x->p_count = 0;
outlet_float(x->p_out1, x->p_count);
if (x->p_changedenom) {
x->p_durdenom = x->p_newdurdenom;
x->p_changedenom = 0;
}
if (x->p_changenumer) {
x->p_durnumer = x->p_newdurnumer;
x->p_changenumer = 0;
}
durcalc(x);
x->p_startremain = 0;
x->p_endremain = x->p_mspbremainder;
x->p_starttime = clock_getlogicaltime();
x->p_endtime = x->p_starttime + x->p_mspbquotient;
// clock_set(x->p_clock, x->p_endtime);
clock_delay(x->p_clock, x->p_mspbquotient);
} else if (i==0 && x->p_onoff) {
x->p_onoff = 0;
clock_unset(x->p_clock);
}
}
static void pulse_bang(Pulse *x)
{
if (!x->p_onoff) {
x->p_onoff = 1;
x->p_count = 0;
outlet_float(x->p_out1, x->p_count);
if (x->p_changedenom) {
x->p_durdenom = x->p_newdurdenom;
x->p_changedenom = 0;
}
if (x->p_changenumer) {
x->p_durnumer = x->p_newdurnumer;
x->p_changenumer = 0;
}
durcalc(x);
x->p_startremain = 0;
x->p_endremain = x->p_mspbremainder;
x->p_starttime = clock_getlogicaltime();
x->p_endtime = x->p_starttime + x->p_mspbquotient;
clock_set(x->p_clock, x->p_endtime);
} else {
x->p_onoff = 0;
clock_unset(x->p_clock);
}
}
/* clock tick routine */
static void pulse_tick(Pulse *x)
{
x->p_count ++;
if ((x->p_maxbeats > 0) && (x->p_count >= x->p_maxbeats)) { /* turn off time */
x->p_onoff = 0;
outlet_bang(x->p_out2);
} else {
outlet_float(x->p_out1, x->p_count);
x->p_startremain = x->p_endremain; /* save in case we have to re do it */
if (x->p_changenumer || x->p_changedenom) { /* duration changed */
if (x->p_changedenom) {
/* this statement may cause a slight drift of (1/(tempo*denom) msecs) */
x->p_startremain = (x->p_startremain * x->p_newdurdenom + (x->p_durdenom>>1))
/x->p_durdenom;
x->p_durdenom = x->p_newdurdenom;
x->p_changedenom = 0;
}
if (x->p_changenumer) {
x->p_durnumer = x->p_newdurnumer;
x->p_changenumer = 0;
}
durcalc(x);
}
x->p_endremain = x->p_startremain + x->p_mspbremainder;
x->p_starttime = x->p_endtime;
x->p_endtime = x->p_starttime + x->p_mspbquotient;
if (x->p_endremain >= x->p_mspbdenom) {
x->p_endremain -= x->p_mspbdenom;
x->p_endtime ++;
}
// clock_set(x->p_clock, x->p_endtime);
clock_delay(x->p_clock, x->p_mspbquotient);
}
}
/* deal with tempo change */
static void pulse_tempo(Pulse *x, t_floatarg t)
{
double time, msecdur, tickdur, fracremain;
t_int fracnumer, fracquotient, oldtempo;
oldtempo = x->p_tempo;
x->p_tempo = (t<5) ? 5 : ((t>500) ? 500 : t);
if (x->p_onoff) {
/* calculate fraction of the beat we have done */
time = clock_getlogicaltime();
if (time != x->p_endtime) {
/* if pulse_tempo is called as a result of a call from pulse_tick
(call chain from outlet_float())
then this stuff doesn't need to be done (time will == x->p_endtime)
*/
msecdur = time - x->p_starttime;
tickdur = msecdur * x->p_mspbdenom - x->p_startremain;
fracnumer = (t_int)(x->p_mspbnumer - tickdur);
durcalc(x);
/* calculate end time */
fracquotient = fracnumer / x->p_mspbdenom;
fracremain = fracnumer % x->p_mspbdenom;
x->p_endtime = time + fracquotient;
x->p_endremain = fracremain;
/* recalculate starttime so future tempo changes work */
x->p_starttime = x->p_endtime - x->p_mspbquotient;
x->p_startremain = x->p_mspbdenom - x->p_mspbremainder + fracremain;
if (x->p_mspbremainder > fracremain) {
x->p_startremain = x->p_mspbdenom - x->p_mspbremainder + fracremain;
x->p_starttime --;
} else {
x->p_startremain = fracremain - x->p_mspbremainder;
}
clock_unset(x->p_clock);
clock_set(x->p_clock, x->p_endtime);
// clock_delay(x->p_clock, fracquotient);
}
}
}
static void pulse_numer(Pulse *x, t_floatarg n)
{
int i = (t_int)n;
if(i >= 0)
{
if (x->p_onoff) {
if (x->p_durnumer != i) {
x->p_changenumer = 1;
x->p_newdurnumer = i;
}
} else {
x->p_durnumer = i;
}
}
}
static void pulse_denom(Pulse *x, t_floatarg n)
{
int i = (t_int)n;
if(i >= 0)
{
if (x->p_onoff) {
if (x->p_durdenom != i) {
x->p_changedenom = 1;
x->p_newdurdenom = i;
}
} else {
x->p_durdenom = i;
}
}
}
static void pulse_beat(Pulse *x, t_floatarg n)
{
int i = (t_int)n;
if(i >= 0)
{
x->p_maxbeats = i;
}
}
static void pulse_free(Pulse *x)
{
clock_free(x->p_clock);
}
/* function run to create a new instance of the Pulse class */
static void *pulse_new(t_floatarg t, t_floatarg n, t_floatarg d, t_floatarg b)
{
Pulse *x;
x = (Pulse *)pd_new(pulse_class); /* allocates memory and sticks in an inlet */
inlet_new(&x->p_ob, &x->p_ob.ob_pd, gensym("float"), gensym("tempo"));
inlet_new(&x->p_ob, &x->p_ob.ob_pd, gensym("float"), gensym("numer"));
inlet_new(&x->p_ob, &x->p_ob.ob_pd, gensym("float"), gensym("denom"));
inlet_new(&x->p_ob, &x->p_ob.ob_pd, gensym("float"), gensym("beat"));
x->p_out1 = outlet_new(&x->p_ob, gensym("float"));
x->p_out2 = outlet_new(&x->p_ob, gensym("float"));
x->p_clock = clock_new(x, (t_method)pulse_tick);
x->p_tempo = (t==0) ? 120 : ((t<5) ? 5 : ((t>500) ? 500 : t));
x->p_durnumer = (n<=0) ? 1 : n;
x->p_durdenom = (d<=0) ? 4 : d;
x->p_maxbeats = (b<=0) ? 0 : b;
x->p_changenumer = 0;
x->p_changedenom = 0;
x->p_onoff = 0;
return (x); /* always return a copy of the created object */
}
#ifndef MAXLIB
void pulse_setup(void)
{
pulse_class = class_new(gensym("pulse"), (t_newmethod)pulse_new,
(t_method)pulse_free, sizeof(Pulse), 0, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0);
class_addmethod(pulse_class, (t_method)pulse_beat, gensym("beat"), A_FLOAT, 0);
class_addmethod(pulse_class, (t_method)pulse_denom, gensym("denom"), A_FLOAT, 0);
class_addmethod(pulse_class, (t_method)pulse_numer, gensym("numer"), A_FLOAT, 0);
class_addmethod(pulse_class, (t_method)pulse_tempo, gensym("tempo"), A_FLOAT, 0);
class_addfloat(pulse_class, pulse_onoff);
class_addbang(pulse_class, pulse_bang);
class_sethelpsymbol(pulse_class, gensym("help-pulse.pd"));
post(version);
}
#else
void maxlib_pulse_setup(void)
{
pulse_class = class_new(gensym("maxlib_pulse"), (t_newmethod)pulse_new,
(t_method)pulse_free, sizeof(Pulse), 0, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0);
class_addcreator((t_newmethod)pulse_new, gensym("pulse"), A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0);
class_addmethod(pulse_class, (t_method)pulse_beat, gensym("beat"), A_FLOAT, 0);
class_addmethod(pulse_class, (t_method)pulse_denom, gensym("denom"), A_FLOAT, 0);
class_addmethod(pulse_class, (t_method)pulse_numer, gensym("numer"), A_FLOAT, 0);
class_addmethod(pulse_class, (t_method)pulse_tempo, gensym("tempo"), A_FLOAT, 0);
class_addfloat(pulse_class, pulse_onoff);
class_addbang(pulse_class, pulse_bang);
class_sethelpsymbol(pulse_class, gensym("maxlib/help-pulse.pd"));
}
#endif
--- NEW FILE: chord.c ---
/* ------------------------- chord ------------------------------------------ */
/* */
/* Tries to detect a chord (or any harmonic relations) of incoming notes. */
/* Written by Olaf Matthes (olaf.matthes(a)gmx.de) */
/* Get source at http://www.akustische-kunst.org/puredata/maxlib/ */
/* */
/* This program is free software; you can redistribute it and/or */
/* modify it under the terms of the GNU General Public License */
/* as published by the Free Software Foundation; either version 2 */
/* of the License, or (at your option) any later version. */
/* */
/* This program is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
/* GNU General Public License for more details. */
/* */
/* You should have received a copy of the GNU General Public License */
/* along with this program; if not, write to the Free Software */
/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
[...1777 lines suppressed...]
{
chord_class = class_new(gensym("chord"), (t_newmethod)chord_new,
0, sizeof(t_chord), 0, A_DEFFLOAT, 0);
#else
void maxlib_chord_setup(void)
{
chord_class = class_new(gensym("maxlib_chord"), (t_newmethod)chord_new,
0, sizeof(t_chord), 0, A_DEFFLOAT, 0);
#endif
class_addfloat(chord_class, chord_float);
class_addmethod(chord_class, (t_method)chord_ft1, gensym("ft1"), A_FLOAT, 0);
#ifndef MAXLIB
class_sethelpsymbol(chord_class, gensym("help-chord.pd"));
post(version);
#else
class_addcreator((t_newmethod)chord_new, gensym("chord"), A_DEFFLOAT, 0);
class_sethelpsymbol(chord_class, gensym("maxlib/help-chord.pd"));
#endif
}
--- NEW FILE: rhythm.c ---
/* --------------------------- rhythm ---------------------------------------- */
/* */
/* Detect the beats per minute of a MIDI stream. */
/* Written by Olaf Matthes (olaf.matthes(a)gmx.de) */
/* Based on code written by Robert Rowe. */
/* Get source at http://www.akustische-kunst.org/puredata/maxlib/ */
/* */
/* This program is free software; you can redistribute it and/or */
/* modify it under the terms of the GNU General Public License */
/* as published by the Free Software Foundation; either version 2 */
/* of the License, or (at your option) any later version. */
/* */
/* This program is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
/* GNU General Public License for more details. */
/* */
/* You should have received a copy of the GNU General Public License */
/* along with this program; if not, write to the Free Software */
/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/* */
/* Based on PureData by Miller Puckette and others. */
/* */
/* ---------------------------------------------------------------------------- */
#include "m_pd.h"
#include <stdio.h>
#include <math.h>
#ifdef UNIX
#include <stdlib.h>
#endif
#define ALPHA 10
#define ADAPT_ARRAY_SIZE 1000
#ifndef M_PI
#define M_PI 3.14159265358979
#endif
#ifndef TWO_PI
#define TWO_PI 2.0*M_PI
#endif
static char *version = "rhythm v0.1, written by Olaf Matthes <olaf.matthes(a)gmx.de>";
typedef struct rhythm
{
t_object x_ob;
t_clock *x_tick;
t_outlet *x_out_bpm; /* beats per minute */
t_outlet *x_out_period; /* beats in milliseconds */
t_outlet *x_out_pulse;
t_int x_print; /* switch printing to console window on / off */
t_int x_ticking; /* indicates if clock is ticking or not */
t_int x_model; /* algorhythm to use: 0 - Large & Kolen, 1 - Toiviainen */
t_float x_long_term[ADAPT_ARRAY_SIZE];
t_float x_short_term[ADAPT_ARRAY_SIZE];
t_float x_phi_at_pulse; /* phase at latest pulse */
t_float x_phiVel_at_pulse; /* phase velocity */
t_float x_adapt;
t_float x_errFunc; /* error function */
t_float x_etaLong; /* strength of long-term adaptation */
t_float x_etaShort; /* strength of short-term adaptation */
t_float x_gamma; /* gain parameter */
double x_lastIoi; /* last inter-onset interval */
double x_lastPulseTime; /* time of last pulse */
t_float x_output; /* current output value of the oscillator */
t_float x_phi; /* phase */
double x_expected; /* estimated time of arrival */
t_float x_period;
t_float x_periodStrength;
t_float x_phaseStrength;
double x_startTime;
t_int x_pitch;
t_int x_velo;
/* helpers needed to do the time calculations */
double x_last_input;
} t_rhythm;
/* --------------- rhythm stuff ------------------------------------------------ */
/* bang at the rhythm's pulse */
static void rhythm_tick(t_rhythm *x)
{
outlet_bang(x->x_out_pulse);
clock_delay(x->x_tick, x->x_period);
}
static t_float rhythm_get_adapt_long(t_rhythm *x, t_float arg)
{
int address;
if (arg > 1.0)
address = ADAPT_ARRAY_SIZE - 1;
else if (arg < -1.0)
address = ADAPT_ARRAY_SIZE - 1;
else
address = abs((int)(arg*1000.0));
return x->x_long_term[address];
}
static t_float rhythm_get_adapt_short(t_rhythm *x, t_float arg)
{
int address;
if (arg > 1.0)
address = ADAPT_ARRAY_SIZE - 1;
else if (arg < -1.0)
address = ADAPT_ARRAY_SIZE - 1;
else
address = abs((int)(arg*1000.0));
return x->x_short_term[address];
}
/* Large & Kolen adaptation model */
static void rhythm_large(t_rhythm *x, t_int pulse, double time)
{
while (time > (x->x_expected+(x->x_period/2))) // move the expectation point
x->x_expected += x->x_period; // to be within one period of onset
x->x_phi = (t_float)(time - x->x_expected) / x->x_period; // calculate phi
if (pulse) { // if this was an onset
x->x_adapt = x->x_gamma * (cos(TWO_PI*x->x_phi)-1.0);
x->x_adapt = 1.0 / cosh(x->x_adapt);
x->x_adapt *= x->x_adapt;
x->x_adapt *= sin(TWO_PI*x->x_phi);
x->x_adapt *= (x->x_period / TWO_PI);
x->x_period += (x->x_periodStrength*x->x_adapt); // update period
x->x_expected += (x->x_phaseStrength *x->x_adapt); // and phase
x->x_phi = (t_float)(time - x->x_expected) / x->x_period;
}
x->x_output = 1+tanh(x->x_gamma*(cos(TWO_PI*x->x_phi)-1.0)); // oscillator output
}
/* Toiviainen adaptation model */
static void rhythm_toiviainen(t_rhythm *x, t_int pulse, double time)
{
t_float deltaTime, varPhi, adaptLong, adaptShort;
/* if just starting, initialize phi */
if(x->x_lastPulseTime < 0)
{
x->x_phi = x->x_phi_at_pulse + x->x_phiVel_at_pulse * ((t_float)(time-x->x_startTime) / 1000.0);
}
else
{
deltaTime = time - x->x_lastPulseTime;
varPhi = (deltaTime/1000.0) * x->x_phiVel_at_pulse;
adaptLong = rhythm_get_adapt_long(x, varPhi); // get long adaptation from table
adaptShort = rhythm_get_adapt_short(x, varPhi); // get short adaptation from table
x->x_phi = x->x_phi_at_pulse + varPhi + x->x_errFunc * (x->x_etaLong*adaptLong + x->x_etaShort*adaptShort);
if (pulse) // change tempo if on pulse
x->x_phiVel_at_pulse = x->x_phiVel_at_pulse * (1 + x->x_etaLong * x->x_errFunc * adaptShort);
}
if (pulse) {
x->x_output = 1+tanh(x->x_gamma*(cos(TWO_PI*x->x_phi)-1.0));
x->x_errFunc = x->x_output * (x->x_output - 2.0) * sin(TWO_PI * x->x_phi);
x->x_phi_at_pulse = x->x_phi;
}
x->x_period = 1000.0 / x->x_phiVel_at_pulse; // update period
}
static void rhythm_move(t_rhythm *x, t_int pulse, double time)
{
switch (x->x_model) /* choose adaptation model */
{
case 0:
rhythm_large(x, pulse, time);
break;
case 1:
rhythm_toiviainen(x, pulse, time);
break;
}
if(x->x_ticking == 0)
{
x->x_ticking = 1; /* prevent us from further calls */
clock_delay(x->x_tick, 0); /* start pulse bangs */
}
}
/* main processing function */
static void rhythm_float(t_rhythm *x, t_floatarg f)
{
t_int velo = x->x_velo;
double time = clock_gettimesince(x->x_last_input);
x->x_pitch = (t_int)f;
if(velo != 0) /* note-on received */
{
if (x->x_startTime == 0) {
x->x_startTime = time;
return;
}
if (x->x_period < 2.0) {
x->x_period = (t_float)(time - x->x_startTime);
x->x_phiVel_at_pulse = 1000.0 / x->x_period;
}
rhythm_move(x, 1, time);
if (x->x_lastPulseTime >= 0)
{
x->x_lastIoi = time - x->x_lastPulseTime;
}
x->x_lastPulseTime = time;
x->x_last_input = clock_getlogicaltime();
outlet_float(x->x_out_period, x->x_period);
outlet_float(x->x_out_bpm, 60000.0/x->x_period);
}
return;
}
/* get velocity */
static void rhythm_ft1(t_rhythm *x, t_floatarg f)
{
x->x_velo = (t_int)f;
}
/* toggle printing on/off (not used right now!) */
static void rhythm_print(t_rhythm *x)
{
if(x->x_print)x->x_print = 0;
else x->x_print = 1;
}
/* initialise array for Toiviainen adaptation model */
static void rhythm_calculate_adaptations(t_rhythm *x)
{
int i;
t_float f;
for(i = 0; i < ADAPT_ARRAY_SIZE; i++)
{
f = (t_float)i/(t_float)ADAPT_ARRAY_SIZE;
x->x_long_term[i] = f+(ALPHA*f*f/2.0+2.0*f+3.0/ALPHA)*exp(-ALPHA*f)-3.0/ALPHA;
x->x_short_term[i] = 1.0-(ALPHA*ALPHA*f*f/2.0+ALPHA*f+1.0)*exp(-ALPHA*f);
}
}
static void rhythm_reset(t_rhythm *x)
{
if(x->x_ticking)clock_unset(x->x_tick);
x->x_ticking = 0;
x->x_gamma = 1.0; /* default value for gain parameter */
x->x_phi = 0.0;
x->x_output = 1+tanh(x->x_gamma*(cos(TWO_PI*x->x_phi)-1.0));
x->x_expected = 0;
x->x_lastIoi = 0;
x->x_lastPulseTime = -1;
x->x_period = 1.0;
x->x_periodStrength = 0.2;
x->x_phaseStrength = 0.2;
x->x_errFunc = 0.0;
x->x_etaLong = 0.2;
x->x_etaShort = 0.2;
x->x_phi_at_pulse = 0.0;
x->x_phiVel_at_pulse = 0.9;
x->x_startTime = 0;
rhythm_calculate_adaptations(x);
}
static void rhythm_model(t_rhythm *x, t_floatarg f)
{
if(f == 1)
{
x->x_model = 1; /* Toiviainen model */
rhythm_reset(x);
post("rhythm: using \"Toiviainen\" adaptation model");
}
else
{
x->x_model = 0; /* Large and Kolen model */
rhythm_reset(x);
post("rhythm: using \"Large and Kolen\" adaptation model");
}
}
static t_class *rhythm_class;
static void rhythm_free(t_rhythm *x)
{
clock_free(x->x_tick);
}
static void *rhythm_new(t_floatarg f)
{
t_rhythm *x = (t_rhythm *)pd_new(rhythm_class);
inlet_new(&x->x_ob, &x->x_ob.ob_pd, gensym("float"), gensym("ft1"));
x->x_out_bpm = outlet_new(&x->x_ob, gensym("float"));
x->x_out_period = outlet_new(&x->x_ob, gensym("float"));
x->x_out_pulse = outlet_new(&x->x_ob, gensym("bang"));
x->x_tick = clock_new(x, (t_method)rhythm_tick);
rhythm_reset(x);
if(f == 1)
{
x->x_model = 1; /* Toiviainen model */
post("rhythm: using \"Toiviainen\" adaptation model");
}
else
{
x->x_model = 0; /* Large and Kolen model */
post("rhythm: using \"Large and Kolen\" adaptation model");
}
return (void *)x;
}
#ifndef MAXLIB
void rhythm_setup(void)
{
rhythm_class = class_new(gensym("rhythm"), (t_newmethod)rhythm_new,
(t_method)rhythm_free, sizeof(t_rhythm), 0, A_DEFFLOAT, 0);
class_addfloat(rhythm_class, rhythm_float);
class_addmethod(rhythm_class, (t_method)rhythm_ft1, gensym("ft1"), A_FLOAT, 0);
class_addmethod(rhythm_class, (t_method)rhythm_model, gensym("model"), A_FLOAT, 0);
class_addmethod(rhythm_class, (t_method)rhythm_reset, gensym("reset"), 0);
class_addmethod(rhythm_class, (t_method)rhythm_print, gensym("print"), 0);
class_sethelpsymbol(rhythm_class, gensym("help-rhythm.pd"));
post(version);
}
#else
void maxlib_rhythm_setup(void)
{
rhythm_class = class_new(gensym("maxlib_rhythm"), (t_newmethod)rhythm_new,
(t_method)rhythm_free, sizeof(t_rhythm), 0, A_DEFFLOAT, 0);
class_addcreator((t_newmethod)rhythm_new, gensym("rhythm"), A_DEFFLOAT, 0);
class_addfloat(rhythm_class, rhythm_float);
class_addmethod(rhythm_class, (t_method)rhythm_ft1, gensym("ft1"), A_FLOAT, 0);
class_addmethod(rhythm_class, (t_method)rhythm_model, gensym("model"), A_FLOAT, 0);
class_addmethod(rhythm_class, (t_method)rhythm_reset, gensym("reset"), 0);
class_addmethod(rhythm_class, (t_method)rhythm_print, gensym("print"), 0);
class_sethelpsymbol(rhythm_class, gensym("maxlib/help-rhythm.pd"));
}
#endif
--- NEW FILE: beta.c ---
/* ---------------------------- rand_beta ------------------------------------- */
/* */
/* rand_beta generates a beta distributed random variable. */
/* Written by Olaf Matthes (olaf.matthes(a)gmx.de) */
/* Based on code found in Dodge/Jerse "Computer Music" */
/* Get source at http://www.akustische-kunst.org/puredata/maxlib/ */
/* */
/* This program is free software; you can redistribute it and/or */
/* modify it under the terms of the GNU General Public License */
/* as published by the Free Software Foundation; either version 2 */
/* of the License, or (at your option) any later version. */
/* */
/* This program is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
/* GNU General Public License for more details. */
/* */
/* You should have received a copy of the GNU General Public License */
/* along with this program; if not, write to the Free Software */
/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/* */
/* Based on PureData by Miller Puckette and others. */
/* */
/* ---------------------------------------------------------------------------- */
#include "m_pd.h"
#include <stdlib.h>
#include <time.h>
#include <math.h>
#define fran() (t_float)rand()/(t_float)RAND_MAX
#ifndef M_PI
#define M_PI 3.1415927
#endif
static char *version = "beta v0.1, generates a beta distributed random variable\n"
" written by Olaf Matthes <olaf.matthes(a)gmx.de>";
/* -------------------------- rand_beta ------------------------------ */
static t_class *rand_beta_class;
typedef struct _rand_beta
{
t_object x_obj;
t_float x_a;
t_float x_b;
} t_rand_beta;
static void *rand_beta_new(t_floatarg a, t_floatarg b)
{
t_rand_beta *x = (t_rand_beta *)pd_new(rand_beta_class);
srand( (unsigned)time( NULL ) );
floatinlet_new(&x->x_obj, &x->x_a);
floatinlet_new(&x->x_obj, &x->x_b);
outlet_new(&x->x_obj, &s_float);
x->x_a = a;
x->x_b = b;
return (x);
}
static void rand_beta_bang(t_rand_beta *x)
{
t_float u1, u2, y01, y2, sum, a, b, ainv, binv;
a = (x->x_a <= 0 ? 0.0001 : x->x_a);
b = (x->x_b <= 0 ? 0.0001 : x->x_b);
ainv = 1/a;
binv = 1/b;
do
{
do
{
u1 = fran();
}
while(u1 == 0);
do
{
u2 = fran();
}
while(u2 == 0);
y01 = pow(u1, ainv);
y2 = pow(u2, binv);
sum = y01 + y2;
}
while(sum > 1);
outlet_float(x->x_obj.ob_outlet, y01/sum);
}
#ifndef MAXLIB
void beta_setup(void)
{
rand_beta_class = class_new(gensym("beta"), (t_newmethod)rand_beta_new, 0,
sizeof(t_rand_beta), 0, A_DEFFLOAT, A_DEFFLOAT, 0);
class_addbang(rand_beta_class, rand_beta_bang);
class_sethelpsymbol(rand_beta_class, gensym("help-beta.pd"));
post(version);
}
#else
void maxlib_beta_setup(void)
{
rand_beta_class = class_new(gensym("maxlib_beta"), (t_newmethod)rand_beta_new, 0,
sizeof(t_rand_beta), 0, A_DEFFLOAT, A_DEFFLOAT, 0);
class_addbang(rand_beta_class, rand_beta_bang);
class_addcreator((t_newmethod)rand_beta_new, gensym("beta"), A_DEFFLOAT, A_DEFFLOAT, 0);
class_sethelpsymbol(rand_beta_class, gensym("maxlib/help-beta.pd"));
}
#endif
--- NEW FILE: gestalt.c ---
/* ------------------------- gestalt ---------------------------------------- */
/* */
/* Find the 'gestalt' of the MIDI input. */
/* Written by Olaf Matthes <olaf.matthes(a)gmx.de> */
/* Get source at http://www.akustische-kunst.org/puredata/maxlib/ */
/* */
/* This program is free software; you can redistribute it and/or */
/* modify it under the terms of the GNU General Public License */
/* as published by the Free Software Foundation; either version 2 */
/* of the License, or (at your option) any later version. */
/* */
/* This program is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
/* GNU General Public License for more details. */
/* */
/* You should have received a copy of the GNU General Public License */
/* along with this program; if not, write to the Free Software */
/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/* */
/* Based on PureData by Miller Puckette and others. */
/* */
/* ---------------------------------------------------------------------------- */
#include "m_pd.h"
#include <math.h>
#include <stdio.h>
#ifdef UNIX
#include <stdlib.h>
#endif
static char *version = "gestalt v0.1, written by Olaf Matthes <olaf.matthes(a)gmx.de>";
typedef struct gestalt
{
t_object x_ob;
t_inlet *x_invelocity; /* inlet for velocity */
t_outlet *x_outgestalt; /* calculated 'gestalt'-value */
t_float x_lastpitch;
t_float x_velocity;
t_float x_reftime;
double x_lastontime;
} t_gestalt;
static void gestalt_ft1(t_gestalt *x, t_floatarg f)
{
x->x_velocity = f;
}
static void gestalt_ft2(t_gestalt *x, t_floatarg f)
{
if(f > 0.0) x->x_reftime = f;
}
static void gestalt_float(t_gestalt *x, t_floatarg f)
{
int interval, pitch, gestalt;
double ontime = clock_getlogicaltime();
if(x->x_velocity) /* only process note-ons */
{
pitch = (t_int)f;
if(pitch < 1) pitch = 0;
if(pitch > 127) pitch = 127;
interval = abs(pitch - x->x_lastpitch);
gestalt = (clock_gettimesince(x->x_lastontime)/x->x_reftime) + interval;
x->x_lastpitch = pitch;
x->x_lastontime = ontime;
/* output values from right to left */
outlet_float(x->x_outgestalt, gestalt);
}
}
static t_class *gestalt_class;
static void *gestalt_new(t_floatarg f)
{
t_gestalt *x = (t_gestalt *)pd_new(gestalt_class);
inlet_new(&x->x_ob, &x->x_ob.ob_pd, gensym("float"), gensym("ft1"));
inlet_new(&x->x_ob, &x->x_ob.ob_pd, gensym("float"), gensym("ft2"));
x->x_outgestalt = outlet_new(&x->x_ob, gensym("float"));
x->x_lastontime = clock_getlogicaltime();
x->x_reftime = f;
if(x->x_reftime < 1) x->x_reftime = 1;
return (void *)x;
}
#ifndef MAXLIB
void gestalt_setup(void)
{
gestalt_class = class_new(gensym("gestalt"), (t_newmethod)gestalt_new,
0, sizeof(t_gestalt), 0, A_DEFFLOAT, 0);
class_addfloat(gestalt_class, gestalt_float);
class_addmethod(gestalt_class, (t_method)gestalt_ft1, gensym("ft1"), A_FLOAT, 0);
class_addmethod(gestalt_class, (t_method)gestalt_ft2, gensym("ft2"), A_FLOAT, 0);
class_sethelpsymbol(gestalt_class, gensym("help-gestalt.pd"));
post(version);
}
#else
void maxlib_gestalt_setup(void)
{
gestalt_class = class_new(gensym("maxlib_gestalt"), (t_newmethod)gestalt_new,
0, sizeof(t_gestalt), 0, A_DEFFLOAT, 0);
class_addcreator((t_newmethod)gestalt_new, gensym("gestalt"), A_DEFFLOAT, 0);
class_addfloat(gestalt_class, gestalt_float);
class_addmethod(gestalt_class, (t_method)gestalt_ft1, gensym("ft1"), A_FLOAT, 0);
class_addmethod(gestalt_class, (t_method)gestalt_ft2, gensym("ft2"), A_FLOAT, 0);
class_sethelpsymbol(gestalt_class, gensym("maxlib/help-gestalt.pd"));
}
#endif
--- NEW FILE: pong.c ---
/* --------------------------- pong ------------------------------------------ */
/* */
/* A virtual bouncing ball. */
/* Written by Olaf Matthes <olaf.matthes(a)gmx.de> */
/* Based on pong (for Max) version 1.5 written by Richard Dudas. */
/* Get source at http://www.akustische-kunst.org/puredata/maxlib/ */
/* */
/* This program is free software; you can redistribute it and/or */
/* modify it under the terms of the GNU General Public License */
/* as published by the Free Software Foundation; either version 2 */
/* of the License, or (at your option) any later version. */
/* */
/* This program is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
/* GNU General Public License for more details. */
/* */
/* You should have received a copy of the GNU General Public License */
/* along with this program; if not, write to the Free Software */
/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/* */
/* Based on PureData by Miller Puckette and others. */
/* */
/* ---------------------------------------------------------------------------- */
#include "m_pd.h"
static char *version = "pong v0.1, ported by Olaf Matthes <olaf.matthes(a)gmx.de>\n"
" written for Max by Richard Dudas";
typedef struct pong
{
t_object x_obj;
t_outlet *p_bounceout;
t_outlet *p_handout;
t_outlet *p_velout;
t_outlet *p_heightout;
t_clock *p_klok;
t_int p_ms; // ms count
t_float p_time; // current time div by warp
t_float p_timegrain; // timegrain in seconds
t_float p_timegrainin; // timegrain in ms
t_float p_warp; // timewarp in ms
t_float p_dinit; // init distance
t_float p_vinit; // init velocity
t_float p_ainit; // base acceleration def -100
t_float p_damping; // realtime multiplicative damping
t_float p_dhand; // virtual hand distance
t_float p_force; // force of hand 1.0 = no force
t_float p_accel; // current accel value
t_float p_vi; // current velocity
t_float p_di; // current distance
t_float p_dt; // distance out
t_float p_dtprev; // previous distance out for accel computation
t_float p_vt; // velocity out
t_int p_prevchg; // for logical transition
} t_pong;
/* ---------------------------------------------------------- */
/* ---- this stuff is mainly for the timer, on off etc... --- */
/* ---------------------------------------------------------- */
static void pong_reset(t_pong *x)
{
x->p_di = x->p_dinit;
x->p_dt = x->p_dinit; // added
x->p_dtprev = x->p_dinit; // added
x->p_vi = x->p_vinit;
x->p_vt = x->p_vinit; // added
x->p_ms = 0;
x->p_time = 0.;
x->p_ainit = -100.; // added, but currently disabled
x->p_accel = -100.; // reactivated (?)
x->p_damping = 1.; // i.e. no initial damping
x->p_prevchg = 0; // added
/* x->p_ms = 0;
x->p_time = 0.;
x->p_timegrain = 0.05; // if ms grain = 50
x->p_timegrainin = 50;
x->p_vinit = 0.;
x->p_dinit = 100.;
x->p_ainit = -100.;
x->p_damping = 1.; // i.e. no initial damping
x->p_dhand = 100.;
x->p_force = 1.; // i.e. hand does nothing initially
x->p_accel = -100.;
x->p_vi = 0.;
x->p_di = 100.;
x->p_dt = 100.; // changed from 0 to 100
x->p_dtprev = 100.; // changed from 0 to 100
x->p_vt = 0.;
x->p_prevchg = 0;
*/
}
/* ---------------------------------------------------------- */
static void pong_timein(t_pong *x, t_floatarg n)
{
int thischg;
x->p_time = n / x->p_warp;
x->p_dt = ((x->p_accel * (x->p_time*x->p_time)) + (x->p_time * x->p_vi) + x->p_di);
x->p_vt = ((x->p_dt - x->p_dtprev) / x->p_timegrain);
if (x->p_dt < 0.)
{
x->p_dt *= -1.;
x->p_di = 0.;
x->p_vi = x->p_vt * (-1. * x->p_damping); // -1 will eventually be a damping variable
//post("vel at bounce %f", x->p_vi);
outlet_bang(x->p_bounceout);
x->p_ms = 0;
//x->p_dtprev= 0.;
}
//else
x->p_dtprev = x->p_dt;
/* ---------------------------------- virtual hand below ------------ */
if (x->p_dt > x->p_dhand) // presuming the hand is initially equal to the dinit
thischg = 1;
else
thischg = 0;
if (thischg != x->p_prevchg)
{
x->p_ms = 0;
x->p_vi = x->p_vt;
x->p_di = x->p_dhand;
if (thischg == 0)
{
x->p_accel = -100.; // x->p_ainit in lieu of -100.
outlet_float(x->p_handout, 0);
}
else
{
x->p_accel = (x->p_force * -100.); // x->p_ainit in lieu of -100.
outlet_float(x->p_handout, 1);
}
}
x->p_prevchg = thischg;
outlet_float(x->p_velout, x->p_vt);
outlet_float(x->p_heightout, x->p_dt);
}
static void pong_onoff(t_pong *x, t_floatarg n)
{
if (n != 0)
clock_delay(x->p_klok, 0);
else
clock_unset(x->p_klok);
}
/* ---------------------------------------------------------- */
static void pong_bang(t_pong *x)
{
x->p_ms = 0;
clock_delay(x->p_klok, 0);
}
static void pong_stop(t_pong *x)
{
clock_unset(x->p_klok);
}
/* ---------------------------------------------------------- */
static void pong_tick(t_pong *x)
{
clock_delay(x->p_klok, (t_int)x->p_timegrainin);
pong_timein(x, x->p_ms);
//outlet_float(x->p_heightout, (float)x->p_ms);
x->p_ms = x->p_ms + x->p_timegrainin;
}
/* ---------------------------------------------------------- */
static void pong_tgrain(t_pong *x, t_floatarg n)
{
x->p_timegrain = n / x->p_warp;
x->p_timegrainin = n;
post("timegrain %f", x->p_timegrain);
}
/* ---------------------------------------------------------- */
static void pong_warpin(t_pong *x, t_floatarg n)
{
x->p_warp = n;
x->p_timegrain = x->p_timegrainin / x->p_warp;
post("timewarp %f ms = one sec", x->p_warp);
}
/* ---------------------------------------------------------- */
/* ----- these are to receive and store the init values ----- */
/* ---------------------------------------------------------- */
static void pong_initdist(t_pong *x, t_floatarg n)
{
x->p_dinit = n;
}
static void pong_initvel(t_pong *x, t_floatarg n)
{
x->p_vinit = n;
}
static void pong_damp(t_pong *x, t_floatarg n)
{
x->p_damping = n;
}
/* ---------------------------------------------------------- */
static void pong_baseacc(t_pong *x, t_floatarg n)
{
//post ("baseaccel currently disabled", 0);
x->p_ainit = n;
x->p_accel = x->p_ainit;
}
/* ---------------------------------------------------------- */
static void pong_hand(t_pong *x, t_floatarg n)
{
x->p_dhand = n;
}
static void pong_force(t_pong *x, t_floatarg n)
{
x->p_force = n;
}
/* ---------------------------------------------------------- */
static t_class *pong_class;
static void *pong_new(t_floatarg n)
{
t_pong *x = (t_pong *)pd_new(pong_class);
x->p_klok = clock_new(x, (t_method)pong_tick);
inlet_new(&x->x_obj, &x->x_obj.ob_pd, gensym("float"), gensym("dist")); // distance
inlet_new(&x->x_obj, &x->x_obj.ob_pd, gensym("float"), gensym("velo")); // velocity
inlet_new(&x->x_obj, &x->x_obj.ob_pd, gensym("float"), gensym("damp")); // damping
inlet_new(&x->x_obj, &x->x_obj.ob_pd, gensym("float"), gensym("force")); // hand force 1.0 = no force
inlet_new(&x->x_obj, &x->x_obj.ob_pd, gensym("float"), gensym("hand")); // virtual hand (distance)
if (n > 0)
x->p_warp = n;
else
x->p_warp = 1000.;
x->p_ms = 0;
x->p_time = 0.;
x->p_timegrain = 0.05; // if ms grain = 50
x->p_timegrainin = 50.0;
x->p_vinit = 0.;
x->p_dinit = 100.;
x->p_ainit = -100.;
x->p_damping = 1.; // i.e. no initial damping
x->p_dhand = 100.;
x->p_force = 1.; // i.e. hand does nothing initially
x->p_accel = -100.;
x->p_vi = 0.;
x->p_di = 100.;
x->p_dt = 100.; // changed from 0 to 100
x->p_dtprev = 100.; // changed from 0 to 100
x->p_vt = 0.;
x->p_prevchg = 0;
x->p_bounceout = outlet_new(&x->x_obj, gensym("bang"));
x->p_handout = outlet_new(&x->x_obj, gensym("float"));
x->p_velout = outlet_new(&x->x_obj, gensym("float"));
x->p_heightout = outlet_new(&x->x_obj, gensym("float"));
return (x);
}
#ifndef MAXLIB
void pong_setup(void)
{
pong_class = class_new(gensym("pong"), (t_newmethod)pong_new,
0, sizeof(t_pong), 0, A_DEFFLOAT, 0);
#else
void maxlib_pong_setup(void)
{
pong_class = class_new(gensym("maxlib_pong"), (t_newmethod)pong_new,
0, sizeof(t_pong), 0, A_DEFFLOAT, 0);
class_addcreator((t_newmethod)pong_new, gensym("pong"), A_DEFFLOAT, 0);
#endif
/* method handlers for inlets */
class_addmethod(pong_class, (t_method)pong_initdist, gensym("dist"), A_FLOAT, 0);
class_addmethod(pong_class, (t_method)pong_initvel, gensym("velo"), A_FLOAT, 0);
class_addmethod(pong_class, (t_method)pong_damp, gensym("damp"), A_FLOAT, 0);
class_addmethod(pong_class, (t_method)pong_force, gensym("force"), A_FLOAT, 0);
class_addmethod(pong_class, (t_method)pong_hand, gensym("hand"), A_FLOAT, 0);
/* method handlers for other messages to first inlet */
class_addmethod(pong_class, (t_method)pong_tgrain, gensym("timegrain"), A_FLOAT, 0);
class_addmethod(pong_class, (t_method)pong_warpin, gensym("timewarp"), A_FLOAT, 0);
class_addmethod(pong_class, (t_method)pong_baseacc, gensym("baseaccel"), A_FLOAT, 0);
class_addmethod(pong_class, (t_method)pong_reset, gensym("reset"), 0);
class_addmethod(pong_class, (t_method)pong_stop, gensym("stop"), 0);
class_addfloat(pong_class, pong_onoff);
class_addbang(pong_class, pong_bang);
#ifndef MAXLIB
class_sethelpsymbol(pong_class, gensym("help-pong.pd"));
post(version);
#else
class_sethelpsymbol(pong_class, gensym("maxlib/help-pong.pd"));
#endif
}
--- NEW FILE: urn.c ---
/* ------------------------------- urn -------------------------------------- */
/* */
/* urn - urn selection model (random numbers without repetition). */
/* Written by Olaf Matthes (olaf.matthes(a)gmx.de) */
/* Based on code found in Dodge/Jerse "Computer Music" */
/* Get source at http://www.akustische-kunst.org/puredata/maxlib/ */
/* */
/* This program is free software; you can redistribute it and/or */
/* modify it under the terms of the GNU General Public License */
/* as published by the Free Software Foundation; either version 2 */
/* of the License, or (at your option) any later version. */
/* */
/* This program is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
/* GNU General Public License for more details. */
/* */
/* You should have received a copy of the GNU General Public License */
/* along with this program; if not, write to the Free Software */
/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/* */
/* Based on PureData by Miller Puckette and others. */
/* */
/* ---------------------------------------------------------------------------- */
#include "m_pd.h"
#include <stdlib.h>
#include <time.h>
#include <math.h>
static char *version = "urn v0.1, urn selection model\n"
" written by Olaf Matthes <olaf.matthes(a)gmx.de>";
/* -------------------------- urn ------------------------------ */
static t_class *urn_class;
typedef struct _urn
{
t_object x_obj;
t_outlet *x_numberout;
t_outlet *x_notify;
t_float x_f; /* number of numbers in urn */
t_int x_numbers; /* numbers left in urn */
t_int *x_selected;
unsigned int x_state;
} t_urn;
static int makeseed(void)
{
static unsigned int random_nextseed = 1489853723;
random_nextseed = random_nextseed * 435898247 + 938284287;
return (random_nextseed & 0x7fffffff);
}
static void *urn_new(t_floatarg f)
{
t_urn *x = (t_urn *)pd_new(urn_class);
srand( (unsigned)time( NULL ) );
x->x_numbers = x->x_f = f;
if(x->x_f < 0)x->x_f = 0;
x->x_selected = getbytes(((t_int)x->x_f+1)*sizeof(t_int));
x->x_state = makeseed();
inlet_new(&x->x_obj, &x->x_obj.ob_pd, gensym("float"), gensym("f"));
x->x_numberout = outlet_new(&x->x_obj, &s_float);
x->x_notify = outlet_new(&x->x_obj, &s_bang);
return (x);
}
/* set new size of urn */
static void urn_f(t_urn *x, t_floatarg f)
{
int i;
if(f < 0)
f = 0;
freebytes(x->x_selected, ((t_int)x->x_f+1)*sizeof(t_int));
x->x_numbers = x->x_f = f;
x->x_selected = getbytes(((t_int)x->x_f+1)*sizeof(t_int));
for(i = 0; i <= x->x_f; i++)
x->x_selected[i] = 0;
}
/* clear (refill) urn */
static void urn_clear(t_urn *x)
{
int i;
x->x_numbers = x->x_f;
for(i = 0; i <= x->x_f; i++)
x->x_selected[i] = 0;
}
static void urn_seed(t_urn *x, float f, float glob)
{
x->x_state = f;
}
/* choose from urn */
static void urn_bang(t_urn *x)
{
int n = x->x_f, nval;
int range = (n < 1 ? 1 : n);
unsigned int randval = x->x_state;
if(x->x_numbers == 0)
goto notify;
do
{
x->x_state = randval = randval * 472940017 + 832416023;
nval = ((double)range) * ((double)randval)
* (1./4294967296.);
if (nval >= range) nval = range-1;
}
while(x->x_selected[nval]);
x->x_selected[nval] = 1;
outlet_float(x->x_numberout, nval);
if(--x->x_numbers == 0) /* urn is now empty */
goto notify;
return;
notify:
outlet_bang(x->x_notify);
}
#ifndef MAXLIB
void urn_setup(void)
{
urn_class = class_new(gensym("urn"), (t_newmethod)urn_new, 0,
sizeof(t_urn), 0, A_DEFFLOAT, 0);
#else
void maxlib_urn_setup(void)
{
urn_class = class_new(gensym("maxlib_urn"), (t_newmethod)urn_new, 0,
sizeof(t_urn), 0, A_DEFFLOAT, 0);
class_addcreator((t_newmethod)urn_new, gensym("urn"), A_DEFFLOAT, 0);
#endif
class_addbang(urn_class, urn_bang);
class_addmethod(urn_class, (t_method)urn_f, gensym("f"), A_FLOAT, 0);
class_addmethod(urn_class, (t_method)urn_clear, gensym("clear"), 0);
class_addmethod(urn_class, (t_method)urn_seed, gensym("seed"), A_FLOAT, 0);
#ifndef MAXLIB
class_sethelpsymbol(urn_class, gensym("help-urn.pd"));
post(version);
#else
class_sethelpsymbol(urn_class, gensym("maxlib/help-urn.pd"));
#endif
}
--- NEW FILE: allow.c ---
/* ---------------------------- allow --------------------------------------- */
/* */
/* Lets only floats/symbols through that are allowed to do so. */
/* Written by Olaf Matthes <olaf.matthes(a)gmx.de> */
/* Get source at http://www.akustische-kunst.org/puredata/maxlib/ */
/* */
/* This program is free software; you can redistribute it and/or */
/* modify it under the terms of the GNU General Public License */
/* as published by the Free Software Foundation; either version 2 */
/* of the License, or (at your option) any later version. */
/* */
/* This program is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
/* GNU General Public License for more details. */
/* */
/* You should have received a copy of the GNU General Public License */
/* along with this program; if not, write to the Free Software */
/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/* */
/* Based on PureData by Miller Puckette and others. */
/* */
/* ---------------------------------------------------------------------------- */
#include "m_pd.h"
#include <string.h>
static char *version = "allow v0.1, written by Olaf Matthes <olaf.matthes(a)gmx.de>";
typedef struct allow
{
t_object x_obj;
t_outlet *x_out;
t_atom *x_elem; // list of elemets that are allowed to pass
t_int x_numelem; // the number of elemetns in our allow-list
} t_allow;
/* we got a symbol... */
static void allow_symbol(t_allow *x, t_symbol *s)
{
int i;
for(i = 0; i < x->x_numelem; i++)
{
if(x->x_elem[i].a_type == A_SYMBOL) // compare with all symbols in our list
if(atom_getsymbolarg(i, x->x_numelem, x->x_elem) == s)
{
outlet_symbol(x->x_out, s);
return;
}
}
}
/* we got a float... */
static void allow_float(t_allow *x, t_floatarg f)
{
int i;
for(i = 0; i < x->x_numelem; i++)
{
if(x->x_elem[i].a_type == A_FLOAT) // compare with all floats in our list
if(atom_getfloatarg(i, x->x_numelem, x->x_elem) == f)
{
outlet_float(x->x_out, f);
return;
}
}
}
static t_class *allow_class;
static void allow_free(t_allow *x)
{
freebytes(x->x_elem, x->x_numelem*sizeof(t_atom));
}
static void *allow_new(t_symbol *s, int argc, t_atom *argv)
{
t_allow *x = (t_allow *)pd_new(allow_class);
x->x_numelem = argc; // get the number of elements
x->x_elem = getbytes(argc*sizeof(t_atom));
memcpy(x->x_elem, argv, argc*sizeof(t_atom));
x->x_out = outlet_new(&x->x_obj, gensym("anything"));
// post("allow: got %d elements", x->x_numelem);
return (x);
}
#ifndef MAXLIB
void allow_setup(void)
{
/* the object's class: */
allow_class = class_new(gensym("allow"), (t_newmethod)allow_new,
(t_method)allow_free, sizeof(t_allow), 0, A_GIMME, 0);
#else
void maxlib_allow_setup(void)
{
/* the object's class: */
allow_class = class_new(gensym("maxlib_allow"), (t_newmethod)allow_new,
(t_method)allow_free, sizeof(t_allow), 0, A_GIMME, 0);
class_addcreator((t_newmethod)allow_new, gensym("allow"), A_GIMME, 0);
#endif
class_addsymbol(allow_class, allow_symbol);
class_addfloat(allow_class, allow_float);
#ifndef MAXLIB
class_sethelpsymbol(allow_class, gensym("help-allow.pd"));
post(version);
#else
class_sethelpsymbol(allow_class, gensym("maxlib/help-allow.pd"));
#endif
}
--- NEW FILE: split.c ---
/* ------------------------- split ------------------------------------------ */
/* */
/* splits input to lie within an output range. */
/* Written by Olaf Matthes <olaf.matthes(a)gmx.de> */
/* Get source at http://www.akustische-kunst.org/puredata/maxlib/ */
/* */
/* This program is free software; you can redistribute it and/or */
/* modify it under the terms of the GNU General Public License */
/* as published by the Free Software Foundation; either version 2 */
/* of the License, or (at your option) any later version. */
/* */
/* This program is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
/* GNU General Public License for more details. */
/* */
/* You should have received a copy of the GNU General Public License */
/* along with this program; if not, write to the Free Software */
/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/* */
/* Based on PureData by Miller Puckette and others. */
/* */
/* ---------------------------------------------------------------------------- */
#include "m_pd.h"
#include <stdio.h>
#include <math.h>
static char *version = "split v0.1, written by Olaf Matthes <olaf.matthes(a)gmx.de>";
typedef struct split
{
t_object x_ob;
t_float x_min; /* low border of input range */
t_float x_max; /* high border of input range */
t_int x_revert; /* range is inverted */
t_outlet *x_outlet1; /* path-through outlet */
t_outlet *x_outlet2; /* split outlet */
} t_split;
static void split_float(t_split *x, t_floatarg f)
{
if(x->x_max >= x->x_min)
{
if(f <= x->x_max && f >= x->x_min)
outlet_float(x->x_outlet1, f);
else
outlet_float(x->x_outlet2, f);
}
else
{
if(f >= x->x_max && f <= x->x_min)
outlet_float(x->x_outlet1, f);
else
outlet_float(x->x_outlet2, f);
}
}
static t_class *split_class;
static void *split_new(t_floatarg fmin, t_floatarg fmax)
{
t_split *x = (t_split *)pd_new(split_class);
floatinlet_new(&x->x_ob, &x->x_min);
floatinlet_new(&x->x_ob, &x->x_max);
x->x_outlet1 = outlet_new(&x->x_ob, gensym("float"));
x->x_outlet2 = outlet_new(&x->x_ob, gensym("float"));
x->x_min = fmin;
x->x_max = fmax;
return (void *)x;
}
#ifndef MAXLIB
void split_setup(void)
{
split_class = class_new(gensym("split"), (t_newmethod)split_new,
0, sizeof(t_split), 0, A_DEFFLOAT, A_DEFFLOAT, 0);
class_addfloat(split_class, split_float);
class_sethelpsymbol(split_class, gensym("help-split.pd"));
post(version);
}
#else
void maxlib_split_setup(void)
{
split_class = class_new(gensym("maxlib_split"), (t_newmethod)split_new,
0, sizeof(t_split), 0, A_DEFFLOAT, A_DEFFLOAT, 0);
class_addcreator((t_newmethod)split_new, gensym("split"), A_DEFFLOAT, A_DEFFLOAT, 0);
class_addfloat(split_class, split_float);
class_sethelpsymbol(split_class, gensym("maxlib/help-split.pd"));
}
#endif
--- NEW FILE: listfunnel.c ---
/* ------------------------- listfunnel ------------------------------------- */
/* */
/* Convert list into two-element lists with source index. */
/* Written by Olaf Matthes (olaf.matthes(a)gmx.de) */
/* Get source at http://www.akustische-kunst.org/puredata/maxlib/ */
/* */
/* This program is free software; you can redistribute it and/or */
/* modify it under the terms of the GNU General Public License */
/* as published by the Free Software Foundation; either version 2 */
/* of the License, or (at your option) any later version. */
/* */
/* This program is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
/* GNU General Public License for more details. */
/* */
/* You should have received a copy of the GNU General Public License */
/* along with this program; if not, write to the Free Software */
/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/* */
/* Based on PureData by Miller Puckette and others. */
/* */
/* ---------------------------------------------------------------------------- */
#include "m_pd.h"
#include <stdio.h>
#include <stdlib.h>
static char *version = "listfunnel v0.1, written by Olaf Matthes <olaf.matthes(a)gmx.de>";
typedef struct listfunnel
{
t_object x_ob;
t_outlet *x_outlet; /* result */
} t_listfunnel;
static void listfunnel_list(t_listfunnel *x, t_symbol *s, int argc, t_atom *argv)
{
int i;
t_atom list[2];
for(i = 0; i < argc; i++)
{
SETFLOAT(list, i);
list[1] = argv[i]; // SETFLOAT(list+1, atom_getfloatarg(i, argc, argv));
outlet_list(x->x_outlet, NULL, 2, list);
}
}
static void listfunnel_float(t_listfunnel *x, t_floatarg f)
{
t_atom list[2];
SETFLOAT(list, 0);
SETFLOAT(list+1, f);
outlet_list(x->x_outlet, NULL, 2, list);
}
static t_class *listfunnel_class;
static void *listfunnel_new(void)
{
int i;
t_listfunnel *x = (t_listfunnel *)pd_new(listfunnel_class);
x->x_outlet = outlet_new(&x->x_ob, gensym("float"));
return (void *)x;
}
#ifndef MAXLIB
void listfunnel_setup(void)
{
listfunnel_class = class_new(gensym("listfunnel"), (t_newmethod)listfunnel_new,
0, sizeof(t_listfunnel), 0, 0, 0);
class_addfloat(listfunnel_class, listfunnel_float);
class_addlist(listfunnel_class, listfunnel_list);
class_sethelpsymbol(listfunnel_class, gensym("help-listfunnel.pd"));
post(version);
}
#else
void maxlib_listfunnel_setup(void)
{
listfunnel_class = class_new(gensym("maxlib_listfunnel"), (t_newmethod)listfunnel_new,
0, sizeof(t_listfunnel), 0, 0, 0);
class_addcreator((t_newmethod)listfunnel_new, gensym("listfunnel"), 0);
class_addfloat(listfunnel_class, listfunnel_float);
class_addlist(listfunnel_class, listfunnel_list);
class_sethelpsymbol(listfunnel_class, gensym("maxlib/help-listfunnel.pd"));
}
#endif
--- NEW FILE: beat.c ---
/* --------------------------- beat ------------------------------------------ */
/* */
/* Detect the beats per minute of a MIDI stream. */
/* Written by Olaf Matthes (olaf.matthes(a)gmx.de) */
/* Based on code written by Robert Rowe. */
/* Get source at http://www.akustische-kunst.org/puredata/maxlib/ */
/* */
/* This program is free software; you can redistribute it and/or */
/* modify it under the terms of the GNU General Public License */
/* as published by the Free Software Foundation; either version 2 */
/* of the License, or (at your option) any later version. */
/* */
/* This program is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
/* GNU General Public License for more details. */
/* */
/* You should have received a copy of the GNU General Public License */
/* along with this program; if not, write to the Free Software */
/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/* */
/* Based on PureData by Miller Puckette and others. */
/* */
/* ---------------------------------------------------------------------------- */
#include "m_pd.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define BEAT_LONG 1500 /* longest time we take into concideration (40 bpm) */
#define BEAT_SHORT 300 /* shortest time we take into concideration (200 bpm) */
static char *version = "beat v0.1, written by Olaf Matthes <olaf.matthes(a)gmx.de>";
typedef struct
{
t_int points; /* number of points assigned to this theory */
double expect; /* time of next expected hit */
t_int onbeat; /* whether (1) or not (0) it was on the beat */
} beat_theory;
typedef struct /* used for sorting theories */
{
t_int points;
t_int theory;
} beat_sort_record;
typedef struct beat
{
t_object x_ob;
t_clock *x_clock;
t_outlet *x_outbpm; /* beat as MIDI note number */
t_outlet *x_outms; /* beat in milliseconds */
t_outlet *x_outbeat; /* send a bang whenever beat is 'on beat' */
t_int x_print; /* switch printing to console window on / off */
t_int x_num_beats; /* number of beats we've received */
double x_beat_period; /* time in ms until next expected beat / beat pulse */
beat_theory x_beats[BEAT_LONG];
double x_beatexpect; /* expected time for next beat */
t_int x_on_beat; /* indicate if last event was on beat */
t_int x_band_percent;
t_int x_pitch;
t_int x_velo;
/* helpers needed to do the time calculations */
double x_this_input;
double x_last_input;
double x_lasttime;
double x_lastlasttime;
} t_beat;
/* ---------------- mathematical functions to work with doubles -------------- */
static double double_abs(double value)
{
if(value < 0)
return (value * -1);
else
return (value);
}
/* --------------- beat stuff ------------------------------------------------ */
/* evaluate results: find theory that is the most likely one and
print out internal data to console window if print is enabled */
static int beat_evaluate(t_beat *x)
{
int i, j, K;
char string[256];
char info[40];
beat_sort_record theories[BEAT_LONG], *sortp, R;
int value; /* the result of the sorting */
for (i = 0; i < BEAT_LONG; i++)
{ /* prepare sort records */
sortp = &(theories[i]);
sortp->points = x->x_beats[i].points;
sortp->theory = i;
}
for (j = 2; j < BEAT_LONG; j++)
{ /* sort */
i = j - 1;
K = theories[j].points;
R = theories[j];
while (i > 0)
{
if (K >= theories[i].points)
{
theories[i+1] = R;
break;
}
else
{
theories[i+1] = theories[i];
i -= 1;
}
}
if (i==0) theories[i+1] = R;
}
/* get leading result */
sortp = &(theories[BEAT_LONG - 1]);
value = sortp->theory; /* get our resulting theory */
if(x->x_print)
{
post(" 0 1 2 3 4 R E");
*string = '\0'; /* print out five leading theories */
sprintf(info, "%4g", x->x_this_input);
strcat(string, info);
for(i = 1; i < 6; i++)
{
sortp = &(theories[BEAT_LONG - i]);
sprintf(info, " %4d[%3d]", sortp->theory, sortp->points);
strcat(string, info);
}
sprintf(info, " %g %g", clock_getlogicaltime(), x->x_beatexpect);
strcat(string, info);
post(string);
}
return value;
}
/* reduce duration to fit into our processing window */
/* some sort of 'double modulo'... */
static double beat_reduce_offset(double duration)
{
double temp = duration;
int divisor = 2; /* first try dividing by two */
while (temp > BEAT_LONG) /* while duration is too long */
temp = duration / divisor++; /* divide by progressively higher divisors */
return temp; /* return a value in bounds */
}
/*
* beat_eligible: determine whether an event is eligible for consideration
* as a beat theory
*/
static int beat_eligible(double candidate, int* offsets, int num_offsets)
{
double diff;
int i;
if (candidate >= BEAT_LONG) /* if too long try subharmonics */
candidate = beat_reduce_offset(candidate);
/* if candidate is close to one already found */
for(i = 0; i < num_offsets; i++)
{
diff = double_abs((candidate - offsets[i]));
if (diff < offsets[i]/20) {
if (candidate > offsets[i])
++offsets[i]; else /* pull existing one */
if (candidate < offsets[i]) /* toward new candidate */
--offsets[i];
return 0; /* declare candidate ineligible */
}
}
return candidate; /* otherwise return legal candidate */
}
static void beat_float(t_beat *x, t_floatarg f)
{
t_int velo = x->x_velo;
int i, j, indx;
int num_offsets, candidate;
int low_limit, high_limit, width, deviation;
int points, band, center_offset, period;
beat_theory* t;
int offsets[7];
static int factors[10] =
{ 200, 50, 300, 150, 66, 400, 600, 133, 33, 75 };
double now = clock_getlogicaltime();
t_float outvalue;
x->x_pitch = (t_int)f;
x->x_this_input = clock_gettimesince(x->x_last_input);
if(velo != 0) /* note-on received */
{
if(++x->x_num_beats == 1)
{
goto time; /* only one event, no beats yet */
}
num_offsets = 0;
candidate = beat_eligible(x->x_this_input, offsets, num_offsets);
if(candidate)
offsets[num_offsets++] = candidate; /* offset[0] set to incoming offset */
if(x->x_num_beats > 2)
{ /* if three events */
/* check previous for eligibility */
candidate = beat_eligible(x->x_lasttime, offsets, num_offsets);
if (candidate)
offsets[num_offsets++] = candidate;
candidate = x->x_this_input + x->x_lasttime; /* add current and previous offsets */
candidate = beat_eligible(candidate, offsets, num_offsets);
if (candidate) /* add to list if eligible */
offsets[num_offsets++] = candidate;
}
if(x->x_num_beats > 3)
{
candidate = beat_eligible(x->x_lastlasttime, offsets, num_offsets);
if (candidate)
offsets[num_offsets++] = candidate;
candidate += x->x_lasttime;
candidate = beat_eligible(candidate, offsets, num_offsets);
if (candidate)
offsets[num_offsets++] = candidate;
}
indx = 0;
for(i = num_offsets; i < 7; i++)
{
offsets[i] = 0;
if (indx >= 10) break;
candidate = 0;
while ((indx < 10) && (!candidate))
candidate = beat_eligible((x->x_this_input * factors[indx++])/100, offsets, num_offsets);
if (candidate)
offsets[num_offsets++] = candidate;
}
for(i = 0; i < num_offsets; i++)
{
band = offsets[i] * x->x_band_percent / 100;
if ((low_limit = offsets[i] - band) < 0) /* add points in a critical band */
low_limit = 0; /* around calculated offset */
if ((high_limit = offsets[i] + band) > BEAT_LONG)
high_limit = BEAT_LONG;
center_offset = offsets[i]; /* midpoint of increment */
points = 0;
for (j = low_limit; j < high_limit; j++)
{
if ((points = x->x_beats[j].points) > 0)
{ /* if there is already activation */
deviation = j - center_offset; /* record deviation from midpoint */
x->x_beats[j].points = 0;
if (deviation < 0) { /* if there is activation below midpoint */
t = &(x->x_beats[j+1]); /* take theory one above prior */
} else
if (deviation > 0) { /* if there is activation above midpoint */
t = &(x->x_beats[j-1]); /* take theory one below prior */
} else
t = &(x->x_beats[j]); /* landed right on it */
t->points = points + (num_offsets-i);
break;
}
}
if (!points)
x->x_beats[center_offset].points = num_offsets - i;
}
/* boost hits, and suppress theories with missed beats */
period = 0;
points = 0;
for (i = BEAT_SHORT; i < BEAT_LONG; i++)
{
t = &(x->x_beats[i]);
width = 5 > (t->expect / 7) ? 5 : (t->expect / 7);
t->expect -= x->x_this_input;
t->onbeat = 0;
if(double_abs(t->expect) <= width) /* lies within range */
{
t->expect = i;
t->onbeat = 1;
if (t->points > 0)
t->points += 4; /* add 4 points */
}
else if(t->expect < 0)
{
t->points -= 8;
t->expect = i;
}
if (t->points < 0) t->points = 0; else
if (t->points > 200) t->points = 200;
if (t->points > points)
{
points = t->points;
period = i;
}
}
x->x_beat_period = (double)period;
t = &(x->x_beats[period]);
x->x_beatexpect = now + (double)t->expect;
x->x_on_beat = t->onbeat;
time:
x->x_lastlasttime = x->x_lasttime;
x->x_lasttime = x->x_this_input; //now;
x->x_last_input = now;
if(x->x_on_beat)outlet_bang(x->x_outbeat);
outvalue = (t_float)beat_evaluate(x);
outlet_float(x->x_outms, outvalue);
if(x->x_beat_period)outlet_float(x->x_outbpm, (t_float)(60000.0 / outvalue));
}
return;
}
static void beat_ft1(t_beat *x, t_floatarg f)
{
x->x_velo = (t_int)f;
}
/* toggle printing on/off */
static void beat_print(t_beat *x)
{
if(x->x_print)x->x_print = 0;
else x->x_print = 1;
}
static void beat_reset(t_beat *x)
{
int i;
for(i = 0; i < BEAT_LONG; i++)
{
x->x_beats[i].points = 0;
x->x_beats[i].expect = i;
x->x_beats[i].onbeat = 0;
}
x->x_lastlasttime = 0;
x->x_lasttime = 0;
x->x_num_beats = 0;
x->x_beat_period = 0;
x->x_on_beat = 0;
}
static t_class *beat_class;
static void beat_free(t_beat *x)
{
/* nothing to do */
}
static void *beat_new(t_floatarg f)
{
t_beat *x = (t_beat *)pd_new(beat_class);
inlet_new(&x->x_ob, &x->x_ob.ob_pd, gensym("float"), gensym("ft1"));
x->x_outbpm = outlet_new(&x->x_ob, gensym("float"));
x->x_outms = outlet_new(&x->x_ob, gensym("float"));
x->x_outbeat = outlet_new(&x->x_ob, gensym("bang"));
beat_reset(x);
x->x_band_percent = 4; /* allow 4% 'jitter' by default */
if(f)x->x_band_percent = (t_int)f;
post("beat: band percentage set to %d", x->x_band_percent);
return (void *)x;
}
#ifndef MAXLIB
void beat_setup(void)
{
beat_class = class_new(gensym("beat"), (t_newmethod)beat_new,
(t_method)beat_free, sizeof(t_beat), 0, A_DEFFLOAT, 0);
#else
void maxlib_beat_setup(void)
{
beat_class = class_new(gensym("maxlib_beat"), (t_newmethod)beat_new,
(t_method)beat_free, sizeof(t_beat), 0, A_DEFFLOAT, 0);
#endif
class_addfloat(beat_class, beat_float);
class_addmethod(beat_class, (t_method)beat_ft1, gensym("ft1"), A_FLOAT, 0);
class_addmethod(beat_class, (t_method)beat_reset, gensym("reset"), 0);
class_addmethod(beat_class, (t_method)beat_print, gensym("print"), 0);
#ifndef MAXLIB
class_sethelpsymbol(beat_class, gensym("help-beat.pd"));
post(version);
#else
class_addcreator((t_newmethod)beat_new, gensym("beat"), A_DEFFLOAT, 0);
class_sethelpsymbol(beat_class, gensym("maxlib/help-beat.pd"));
#endif
}
--- NEW FILE: rewrap.c ---
/* ------------------------- rewrap ------------------------------------------ */
/* */
/* rewraps input to lie within an output range. */
/* Written by Olaf Matthes <olaf.matthes(a)gmx.de> */
/* Get source at http://www.akustische-kunst.org/puredata/maxlib/ */
/* */
/* This program is free software; you can redistribute it and/or */
/* modify it under the terms of the GNU General Public License */
/* as published by the Free Software Foundation; either version 2 */
/* of the License, or (at your option) any later version. */
/* */
/* This program is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
/* GNU General Public License for more details. */
/* */
/* You should have received a copy of the GNU General Public License */
/* along with this program; if not, write to the Free Software */
/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/* */
/* Based on PureData by Miller Puckette and others. */
/* */
/* ---------------------------------------------------------------------------- */
#include "m_pd.h"
#include <stdio.h>
#include <math.h>
static char *version = "rewrap v0.1, written by Olaf Matthes <olaf.matthes(a)gmx.de>";
typedef struct rewrap
{
t_object x_ob;
t_float x_min; /* low border of input range */
t_float x_max; /* high border of input range */
t_outlet *x_outlet1; /* path-through outlet */
t_outlet *x_outlet2; /* rewrap outlet */
} t_rewrap;
static void rewrap_float(t_rewrap *x, t_floatarg f)
{
t_float min = x->x_min;
t_float max = x->x_max;
t_float range = 2.0f * (max - min);
t_int i;
if(range == 0.0f)
{
f = min;
outlet_float(x->x_outlet2, 0);
}
else if(f < min)
{
float diff = min - f;
float n = ceil(diff / range);
f += n * range;
if(f >= max)
{
f = 2 * max - f;
n -= 0.5;
}
outlet_float(x->x_outlet2, (t_int)(-2.0f * n));
}
else if (f >= max)
{
float diff = f - max;
float n = floor(diff / range) + 1.0f;
f -= n * range;
if(f < min)
{
f = 2 * min - f;
n -= 0.5;
}
outlet_float(x->x_outlet2, (t_int)(2.0f * n));
}
else
outlet_float(x->x_outlet2, 0.0f);
outlet_float(x->x_outlet1, f);
}
static void rewrap_a(t_rewrap *x, t_floatarg a)
{
t_float max = x->x_max;
if(a <= max)
x->x_min = a;
else
{
x->x_min = max;
x->x_max = a;
}
}
static void rewrap_b(t_rewrap *x, t_floatarg b)
{
t_float min = x->x_min;
if(b >= min)
x->x_max = b;
else
{
x->x_max = min;
x->x_min = b;
}
}
static t_class *rewrap_class;
static void *rewrap_new(t_floatarg fmin, t_floatarg fmax)
{
t_rewrap *x = (t_rewrap *)pd_new(rewrap_class);
inlet_new(&x->x_ob, &x->x_ob.ob_pd, gensym("float"), gensym("a"));
inlet_new(&x->x_ob, &x->x_ob.ob_pd, gensym("float"), gensym("b"));
x->x_outlet1 = outlet_new(&x->x_ob, gensym("float"));
x->x_outlet2 = outlet_new(&x->x_ob, gensym("float"));
x->x_min = fmin;
rewrap_b(x, fmax);
return (void *)x;
}
#ifndef MAXLIB
void rewrap_setup(void)
{
rewrap_class = class_new(gensym("rewrap"), (t_newmethod)rewrap_new,
0, sizeof(t_rewrap), 0, A_DEFFLOAT, A_DEFFLOAT, 0);
class_addfloat(rewrap_class, rewrap_float);
class_addmethod(rewrap_class, (t_method)rewrap_a, gensym("a"), A_FLOAT, 0);
class_addmethod(rewrap_class, (t_method)rewrap_b, gensym("b"), A_FLOAT, 0);
class_sethelpsymbol(rewrap_class, gensym("help-rewrap.pd"));
post(version);
}
#else
void maxlib_rewrap_setup(void)
{
rewrap_class = class_new(gensym("maxlib_rewrap"), (t_newmethod)rewrap_new,
0, sizeof(t_rewrap), 0, A_DEFFLOAT, A_DEFFLOAT, 0);
class_addcreator((t_newmethod)rewrap_new, gensym("rewrap"), A_DEFFLOAT, A_DEFFLOAT, 0);
class_addfloat(rewrap_class, rewrap_float);
class_addmethod(rewrap_class, (t_method)rewrap_a, gensym("a"), A_FLOAT, 0);
class_addmethod(rewrap_class, (t_method)rewrap_b, gensym("b"), A_FLOAT, 0);
class_sethelpsymbol(rewrap_class, gensym("maxlib/help-rewrap.pd"));
}
#endif
--- NEW FILE: speedlim.c ---
/* ------------------------- speedlim ----------------------------------------- */
/* */
/* Lets information through only every N milliseconds. */
/* Written by Krzysztof Czaja for his cyclone library. */
/* Modified to fit into maxlib by Olaf Matthes <olaf.matthes(a)gmx.de>. */
/* Get source at http://www.akustische-kunst.org/puredata/maxlib/ */
/* */
/* This program is free software; you can redistribute it and/or */
/* modify it under the terms of the GNU General Public License */
/* as published by the Free Software Foundation; either version 2 */
/* of the License, or (at your option) any later version. */
/* */
/* This program is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
/* GNU General Public License for more details. */
/* */
/* You should have received a copy of the GNU General Public License */
/* along with this program; if not, write to the Free Software */
/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/* */
/* You should have received a copy of the GNU Lesser General Public */
/* License along with this library; if not, write to the */
/* Free Software Foundation, Inc., 59 Temple Place - Suite 330, */
/* Boston, MA 02111-1307, USA. */
/* */
/* Based on PureData by Miller Puckette and others. */
/* */
/* ---------------------------------------------------------------------------- */
/* this is the original copyright notice: */
/* Copyright (c) 1997-2002 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. */
#include <string.h>
#include "m_pd.h"
#define SPEEDLIM_INISIZE 32 /* LATER rethink */
#define SPEEDLIM_MAXSIZE 256 /* not used */
typedef struct _speedlim
{
t_object x_ob;
int x_open;
t_float x_delta;
t_symbol *x_selector;
t_float x_float;
t_symbol *x_symbol;
t_gpointer *x_pointer;
int x_size; /* as allocated */
int x_natoms; /* as used */
t_atom *x_message;
t_atom x_messini[SPEEDLIM_INISIZE];
int x_entered;
t_clock *x_clock;
} t_speedlim;
static t_class *speedlim_class;
/* a caller must check for nrequested > *sizep */
/* returns actual number of atoms: requested (success)
or a default value of initial size (failure) */
/* the result is guaranteed to be >= min(nrequested, inisize) */
static int speedlim_grow(int nrequested, int *sizep, t_atom **bufp,
int inisize, t_atom *bufini)
{
int newsize = *sizep * 2;
while (newsize < nrequested) newsize *= 2;
if (*bufp == bufini)
*bufp = (t_atom *)getbytes(newsize * sizeof(**bufp));
else
*bufp = (t_atom *)resizebytes(*bufp, *sizep * sizeof(**bufp),
newsize * sizeof(**bufp));
if (*bufp)
*sizep = newsize;
else
{
*bufp = bufini;
nrequested = *sizep = inisize;
}
return (nrequested);
}
static void speedlim_dooutput(t_speedlim *x, t_symbol *s, int ac, t_atom *av)
{
x->x_open = 0; /* so there will be no reentrant calls of dooutput */
x->x_entered = 1; /* this prevents a message from being overridden */
clock_unset(x->x_clock);
if (s == &s_bang)
outlet_bang(((t_object *)x)->ob_outlet);
else if (s == &s_float)
outlet_float(((t_object *)x)->ob_outlet, x->x_float);
else if (s == &s_symbol && x->x_symbol)
{
/* if x_symbol is null, then symbol &s_ is passed
by outlet_anything() -> typedmess() */
outlet_symbol(((t_object *)x)->ob_outlet, x->x_symbol);
x->x_symbol = 0;
}
else if (s == &s_pointer && x->x_pointer)
{
/* LATER */
x->x_pointer = 0;
}
else if (s == &s_list)
outlet_list(((t_object *)x)->ob_outlet, &s_list, ac, av);
else if (s)
outlet_anything(((t_object *)x)->ob_outlet, s, ac, av);
x->x_selector = 0;
x->x_natoms = 0;
if (x->x_delta > 0)
clock_delay(x->x_clock, x->x_delta);
else
x->x_open = 1;
x->x_entered = 0;
}
static void speedlim_tick(t_speedlim *x)
{
if (x->x_selector)
speedlim_dooutput(x, x->x_selector, x->x_natoms, x->x_message);
else
x->x_open = 1;
}
static void speedlim_anything(t_speedlim *x, t_symbol *s, int ac, t_atom *av)
{
if (x->x_open)
speedlim_dooutput(x, s, ac, av);
else if (s && s != &s_ && !x->x_entered)
{
if (ac > x->x_size)
/* MAXSIZE not used, not even a warning...
LATER consider clipping */
ac = speedlim_grow(ac, &x->x_size, &x->x_message,
SPEEDLIM_INISIZE, x->x_messini);
x->x_selector = s;
x->x_natoms = ac;
if (ac)
memcpy(x->x_message, av, ac * sizeof(*x->x_message));
}
}
static void speedlim_bang(t_speedlim *x)
{
x->x_selector = &s_bang;
speedlim_anything(x, x->x_selector, 0, 0);
}
static void speedlim_float(t_speedlim *x, t_float f)
{
x->x_selector = &s_float;
x->x_float = f;
speedlim_anything(x, x->x_selector, 0, 0);
}
static void speedlim_symbol(t_speedlim *x, t_symbol *s)
{
x->x_selector = &s_symbol;
x->x_symbol = s;
speedlim_anything(x, x->x_selector, 0, 0);
}
/* LATER gpointer */
static void speedlim_list(t_speedlim *x, t_symbol *s, int ac, t_atom *av)
{
x->x_selector = &s_list;
speedlim_anything(x, x->x_selector, ac, av);
}
static void speedlim_ft1(t_speedlim *x, t_floatarg f)
{
if (f < 0)
f = 0; /* redundant (and CHECKED) */
x->x_delta = f;
/* CHECKED: no rearming --
if clock is set, then new delta value is not used until next tick */
}
static void speedlim_free(t_speedlim *x)
{
if (x->x_message != x->x_messini)
freebytes(x->x_message, x->x_size * sizeof(*x->x_message));
if (x->x_clock)
clock_free(x->x_clock);
}
static void *speedlim_new(t_floatarg f)
{
t_speedlim *x = (t_speedlim *)pd_new(speedlim_class);
x->x_open = 1; /* CHECKED */
x->x_delta = 0;
x->x_selector = 0;
x->x_float = 0;
x->x_symbol = 0;
x->x_pointer = 0;
x->x_size = SPEEDLIM_INISIZE;
x->x_natoms = 0;
x->x_message = x->x_messini;
x->x_entered = 0;
inlet_new((t_object *)x, (t_pd *)x, &s_float, gensym("ft1"));
outlet_new((t_object *)x, &s_anything);
x->x_clock = clock_new(x, (t_method)speedlim_tick);
speedlim_ft1(x, f);
return (x);
}
#ifndef MAXLIB
void speedlim_setup(void)
{
speedlim_class = class_new(gensym("speedlim"), (t_newmethod)speedlim_new,
(t_method)speedlim_free, sizeof(t_speedlim), 0, A_DEFFLOAT, 0);
#else
void maxlib_speedlim_setup(void)
{
speedlim_class = class_new(gensym("maxlib_speedlim"), (t_newmethod)speedlim_new,
(t_method)speedlim_free, sizeof(t_speedlim), 0, A_DEFFLOAT, 0);
class_addcreator((t_newmethod)speedlim_new, gensym("speedlim"), A_DEFFLOAT, 0);
#endif
class_addbang(speedlim_class, speedlim_bang);
class_addfloat(speedlim_class, speedlim_float);
class_addsymbol(speedlim_class, speedlim_symbol);
class_addlist(speedlim_class, speedlim_list);
class_addanything(speedlim_class, speedlim_anything);
class_addmethod(speedlim_class, (t_method)speedlim_ft1, gensym("ft1"), A_FLOAT, 0);
#ifndef MAXLIB
class_sethelpsymbol(speedlim_class, gensym("help-speedlim.pd"));
#else
class_sethelpsymbol(speedlim_class, gensym("maxlib/help-speedlim.pd"));
#endif
}
--- NEW FILE: average.c ---
/* -------------------------- average ----------------------------------------- */
/* */
/* Calculates the average value of the last N elements. */
/* Written by Olaf Matthes (olaf.matthes(a)gmx.de) */
/* Get source at http://www.akustische-kunst.org/puredata/maxlib/ */
/* */
/* This program is free software; you can redistribute it and/or */
/* modify it under the terms of the GNU General Public License */
/* as published by the Free Software Foundation; either version 2 */
/* of the License, or (at your option) any later version. */
/* */
/* This program is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
/* GNU General Public License for more details. */
/* */
/* You should have received a copy of the GNU General Public License */
/* along with this program; if not, write to the Free Software */
/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/* */
/* Based on PureData by Miller Puckette and others. */
/* */
/* ---------------------------------------------------------------------------- */
#include "m_pd.h"
#include <math.h>
#define MAX_ARG 128 /* maximum number of items to average */
static char *version = "average v0.1, written by Olaf Matthes <olaf.matthes(a)gmx.de>";
typedef struct average
{
t_object x_ob;
t_clock *x_clock;
t_inlet *x_inindex;
t_outlet *x_outfloat; /* output the average */
t_outlet *x_outtendency; /* outputs the tendency of the average */
t_int x_limit; /* indicates if input is 'blocked' (1) */
t_int x_index; /* the number of elements to average */
t_float x_input[MAX_ARG]; /* stores the input values we need for averaging */
t_int x_inpointer; /* actual position in above array */
t_float x_average; /* what do you guess ? */
t_float x_lastaverage;
t_int x_mode; /* how to average: linear or geometric */
} t_average;
/* there must be a function for this in math.h but how is the
german 'Fakultät' called in english ???? */
static int normalise(int i)
{
int ret = i;
while(i--)
{
if(i == 0)break;
ret += i;
}
return (ret);
}
static void average_float(t_average *x, t_floatarg f)
{
int i, j = 0;
t_float tendency;
t_float geo = 1.0;
x->x_average = 0;
/* put value into array */
x->x_input[x->x_inpointer] = f;
/* calulate average */
for(i = 0; i < x->x_index; i++)
{
if(x->x_mode == 0) /* linear */
{
x->x_average += x->x_input[i] * (1.0 / (float)x->x_index);
}
else if(x->x_mode == 1) /* geometric */
{
if(x->x_input[i] == 0)x->x_input[i] = 0.001; /* need to cheat a bit... */
geo *= x->x_input[i];
if(i == x->x_index - 1)
x->x_average = pow(geo, (1.0/(float)x->x_index));
}
else if(x->x_mode == 2) /* weighted */
{
x->x_average += x->x_input[(j + x->x_inpointer + x->x_index) % x->x_index] * (float)(x->x_index - (i + 1));
j--; /* go back in array */
/* normalise output */
if(i == x->x_index - 1)
x->x_average = x->x_average / (float)normalise(x->x_index - 1);
} else post("average: internal error!");
}
if(++x->x_inpointer > x->x_index)
{
x->x_inpointer = 0;
if(x->x_lastaverage < x->x_average)
{
tendency = 1; /* getting more */
}
else if(x->x_lastaverage > x->x_average)
{
tendency = -1; /* getting less */
}
else tendency = 0; /* nothing has changed */
outlet_float(x->x_outtendency, tendency);
x->x_lastaverage = x->x_average;
}
outlet_float(x->x_outfloat, x->x_average);
}
static void average_index(t_average *x, t_floatarg f)
{
x->x_index = (t_int)f;
if(x->x_index > MAX_ARG)x->x_index = MAX_ARG;
}
static void average_reset(t_average *x)
{
int i;
/* zeroe out the array */
for(i = 0; i < MAX_ARG; i++)x->x_input[i] = 0.0;
x->x_inpointer = 0;
x->x_average = 0;
x->x_lastaverage = 0;
post("average: reset");
}
static void average_linear(t_average *x)
{
x->x_mode = 0;
post("average: linear");
}
static void average_geometric(t_average *x)
{
x->x_mode = 1;
post("average: geometric");
}
static void average_weight(t_average *x)
{
x->x_mode = 2;
post("average: weighted");
}
static void average_free(t_average *x)
{
/* nothing to do */
}
static t_class *average_class;
static void *average_new(t_floatarg f)
{
int i;
t_average *x = (t_average *)pd_new(average_class);
x->x_inindex = inlet_new(&x->x_ob, &x->x_ob.ob_pd, gensym("float"), gensym("index"));
x->x_outfloat = outlet_new(&x->x_ob, gensym("float"));
x->x_outtendency = outlet_new(&x->x_ob, gensym("float"));
/* zeroe out the array */
for(i = 0; i < MAX_ARG; i++)x->x_input[i] = 0.0;
x->x_index = (t_int)f;
if(x->x_index > MAX_ARG)
{
x->x_index = MAX_ARG;
post("average: set number of items to %d", x->x_index);
}
x->x_inpointer = 0;
x->x_average = 0;
x->x_mode = 0;
return (void *)x;
}
#ifndef MAXLIB
void average_setup(void)
{
average_class = class_new(gensym("average"), (t_newmethod)average_new,
(t_method)average_free, sizeof(t_average), 0, A_DEFFLOAT, 0);
#else
void maxlib_average_setup(void)
{
average_class = class_new(gensym("maxlib_average"), (t_newmethod)average_new,
(t_method)average_free, sizeof(t_average), 0, A_DEFFLOAT, 0);
#endif
class_addmethod(average_class, (t_method)average_reset, gensym("reset"), 0);
class_addmethod(average_class, (t_method)average_linear, gensym("linear"), 0);
class_addmethod(average_class, (t_method)average_geometric, gensym("geometric"), 0);
class_addmethod(average_class, (t_method)average_weight, gensym("weight"), 0);
class_addfloat(average_class, average_float);
class_addmethod(average_class, (t_method)average_index, gensym("index"), A_FLOAT, 0);
#ifndef MAXLIB
post(version);
class_sethelpsymbol(average_class, gensym("help-average.pd"));
#else
class_addcreator((t_newmethod)average_new, gensym("average"), A_DEFFLOAT, 0);
class_sethelpsymbol(average_class, gensym("maxlib/help-average.pd"));
#endif
}
--- NEW FILE: arraycopy.c ---
/* ------------------------- arraycopy --------------------------------------- */
/* */
/* Copy data from one array to another . */
/* Written by Olaf Matthes <olaf.matthes(a)gmx.de> */
/* Get source at http://www.akustische-kunst.org/puredata/maxlib/ */
/* */
/* This program is free software; you can redistribute it and/or */
/* modify it under the terms of the GNU General Public License */
/* as published by the Free Software Foundation; either version 2 */
/* of the License, or (at your option) any later version. */
/* */
/* This program is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
/* GNU General Public License for more details. */
/* */
/* You should have received a copy of the GNU General Public License */
/* along with this program; if not, write to the Free Software */
/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/* */
/* Based on PureData by Miller Puckette and others. */
/* */
/* ---------------------------------------------------------------------------- */
#include "m_pd.h"
#include <stdlib.h>
static char *version = "arraycopy v0.2, written by Olaf Matthes <olaf.matthes(a)gmx.de>";
typedef struct arraycopy
{
t_object x_obj;
t_symbol *x_destarray;
t_symbol *x_sourcearray;
t_garray *x_destbuf;
t_garray *x_sourcebuf;
t_int x_start;
t_int x_end;
t_int x_pos;
short x_print;
} t_arraycopy;
/* choose the destination array to copy to */
static void arraycopy_setdestarray(t_arraycopy *x, t_symbol *s)
{
t_garray *b;
if ((b = (t_garray *)pd_findbyclass(s, garray_class)))
{
// post("arraycopy: destination array set to \"%s\"", s->s_name);
x->x_destbuf = b;
} else {
post("arraycopy: no array \"%s\" (error %d)", s->s_name, b);
x->x_destbuf = 0;
}
}
static void arraycopy_setdest(t_arraycopy *x, t_symbol *s)
{
x->x_destarray = s;
arraycopy_setdestarray(x, x->x_destarray);
}
/* choose the source array to copy from */
static void arraycopy_setsourcearray(t_arraycopy *x, t_symbol *s)
{
t_garray *b;
if ((b = (t_garray *)pd_findbyclass(s, garray_class)))
{
// post("arraycopy: source array set to \"%s\"", s->s_name);
x->x_sourcebuf = b;
} else {
post("arraycopy: no array \"%s\" (error %d)", s->s_name, b);
x->x_sourcebuf = 0;
}
}
/* this is the routine that actually does the copying */
/* get's called directly when we get a 'bang' */
static void arraycopy_docopy(t_arraycopy *x)
{
t_garray *b; /* make local copy of array */
t_float *tab; /* the content itselfe */
t_int items, i;
t_garray *A;
int npoints;
t_float *vec;
if(!x->x_destarray)
{
post("arraycopy: no destination array specified");
return;
}
if(!x->x_sourcearray)
{
post("arraycopy: no source array specified");
return;
}
A = x->x_destbuf;
if ((b = (t_garray *)pd_findbyclass(x->x_sourcearray, garray_class)))
{
// post("arraycopy: source array set to \"%s\"", x->x_sourcearray->s_name);
} else {
post("arraycopy: no array \"%s\" (error %d)", x->x_sourcearray->s_name, b);
return;
}
// read from our array
if (!garray_getfloatarray(b, &items, &tab))
{
post("arraycopy: couldn't read from source array!");
return;
}
if (!(A = (t_garray *)pd_findbyclass(x->x_destarray, garray_class)))
error("arraycopy: %s: no such array", x->x_destarray->s_name);
else if (!garray_getfloatarray(A, &npoints, &vec))
error("arraycopy: %s: bad template ", x->x_destarray->s_name);
else
{
if(x->x_start > items) // check start point
{
post("arraycopy: source start point out of range for the array given");
return;
}
if(x->x_end) // end point is specified
{
if(x->x_end > items) // check start point
{
post("arraycopy: source end point out of range for the array given");
x->x_end = items;
}
}
else x->x_end = items;
if(x->x_pos)
vec += x->x_pos;
for(i = x->x_start; i < x->x_end; i++)
{
*vec++ = tab[i];
}
garray_redraw(A);
if(x->x_print)post("arraycopy: copied %d values from array \"%s\" to array \"%s\"",
x->x_end-x->x_start, x->x_sourcearray->s_name, x->x_destarray->s_name);
}
}
static void arraycopy_list(t_arraycopy *x, t_symbol *s, int argc, t_atom *argv)
{
if(argc > 1) {
x->x_sourcearray = atom_getsymbolarg(0, argc, argv);
x->x_destarray = atom_getsymbolarg(1, argc, argv);
}
}
static void arraycopy_source(t_arraycopy *x, t_symbol *s)
{
x->x_sourcearray = s;
x->x_start = x->x_end = x->x_pos = 0;
arraycopy_docopy(x);
}
static void arraycopy_print(t_arraycopy *x, t_floatarg f)
{
if(f)
x->x_print = 1;
else
x->x_print = 0;
}
static void arraycopy_copy(t_arraycopy *x, t_symbol *s, int argc, t_atom *argv)
{
if(argc == 1) // source array name supplied
{
x->x_sourcearray = atom_getsymbolarg(0, argc, argv);
x->x_start = x->x_end = x->x_pos = 0;
}
else if(argc == 2) // array name and start point supplied
{
x->x_sourcearray = atom_getsymbolarg(0, argc, argv);
x->x_start = atom_getfloatarg(1, argc, argv);
x->x_end = x->x_pos = 0;
}
else if(argc == 3) // arrayname and start & end point supplied
{
x->x_sourcearray = atom_getsymbolarg(0, argc, argv);
x->x_start = atom_getfloatarg(1, argc, argv);
if(argv[2].a_type == A_FLOAT) // real position
{
x->x_end = atom_getfloatarg(2, argc, argv);
}
else // offset given
{
t_symbol *offset = atom_getsymbolarg(2, argc, argv);
x->x_end = (t_int)atoi(offset->s_name) + x->x_start;
}
x->x_pos = 0;
}
else if(argc == 4) // as above & dest. array
{
x->x_sourcearray = atom_getsymbolarg(0, argc, argv);
x->x_start = atom_getfloatarg(1, argc, argv);
if(argv[2].a_type == A_FLOAT) // real position
{
x->x_end = atom_getfloatarg(2, argc, argv);
}
else // offset given
{
t_symbol *offset = atom_getsymbolarg(2, argc, argv);
x->x_end = (t_int)atoi(offset->s_name) + x->x_start;
}
x->x_destarray = atom_getsymbolarg(3, argc, argv);
arraycopy_setdestarray(x, x->x_destarray);
x->x_pos = 0;
}
else if(argc == 5) // as above & dest. array & pos. in dest.
{
x->x_sourcearray = atom_getsymbolarg(0, argc, argv);
x->x_start = atom_getfloatarg(1, argc, argv);
if(argv[2].a_type == A_FLOAT) // real position
{
x->x_end = atom_getfloatarg(2, argc, argv);
}
else // offset given
{
t_symbol *offset = atom_getsymbolarg(2, argc, argv);
x->x_end = (t_int)atoi(offset->s_name) + x->x_start;
}
x->x_destarray = atom_getsymbolarg(3, argc, argv);
arraycopy_setdestarray(x, x->x_destarray);
x->x_pos = atom_getfloatarg(4, argc, argv);
}
else post("arraycopy: copy: wrong number of arguments");
arraycopy_docopy(x);
}
static t_class *arraycopy_class;
static void *arraycopy_new(t_symbol *s, int argc, t_atom *argv)
{
t_arraycopy *x = (t_arraycopy *)pd_new(arraycopy_class);
if (argc > 0) {
x->x_destarray = atom_getsymbolarg(0, argc, argv);
arraycopy_setdestarray(x, x->x_destarray);
}
inlet_new(&x->x_obj, &x->x_obj.ob_pd, gensym("symbol"), gensym("dest"));
x->x_start = x->x_end = x->x_pos = x->x_print = 0;
return (x);
}
#ifndef MAXLIB
void arraycopy_setup(void)
{
/* the object's class: */
arraycopy_class = class_new(gensym("arraycopy"), (t_newmethod)arraycopy_new,
0, sizeof(t_arraycopy), 0, A_GIMME, 0);
#else
void maxlib_arraycopy_setup(void)
{
/* the object's class: */
arraycopy_class = class_new(gensym("maxlib_arraycopy"), (t_newmethod)arraycopy_new,
0, sizeof(t_arraycopy), 0, A_GIMME, 0);
class_addcreator((t_newmethod)arraycopy_new, gensym("arraycopy"), A_GIMME, 0);
#endif
class_addmethod(arraycopy_class, (t_method)arraycopy_copy, gensym("copy"), A_GIMME, 0);
class_addmethod(arraycopy_class, (t_method)arraycopy_print, gensym("print"), A_FLOAT, 0);
class_addmethod(arraycopy_class, (t_method)arraycopy_setdest, gensym("dest"), A_SYMBOL, 0);
class_addsymbol(arraycopy_class, arraycopy_source);
class_addbang(arraycopy_class, arraycopy_docopy);
// class_addlist(arraycopy_class, arraycopy_list);
#ifndef MAXLIB
class_sethelpsymbol(arraycopy_class, gensym("help-arraycopy.pd"));
post(version);
#else
class_sethelpsymbol(arraycopy_class, gensym("maxlib/help-arraycopy.pd"));
#endif
}
--- NEW FILE: delta.c ---
/* ------------------------- delta ------------------------------------------ */
/* */
/* Claculate 1st or 2nd order difference. */
/* Written by Olaf Matthes (olaf.matthes(a)gmx.de) */
/* Inspired by code written by Trond Lossius. */
/* Get source at http://www.akustische-kunst.org/puredata/maxlib/ */
/* */
/* This program is free software; you can redistribute it and/or */
/* modify it under the terms of the GNU General Public License */
/* as published by the Free Software Foundation; either version 2 */
/* of the License, or (at your option) any later version. */
/* */
/* This program is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
/* GNU General Public License for more details. */
/* */
/* You should have received a copy of the GNU General Public License */
/* along with this program; if not, write to the Free Software */
/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/* */
/* Based on PureData by Miller Puckette and others. */
/* */
/* ---------------------------------------------------------------------------- */
#include "m_pd.h"
#include <stdio.h>
#define MAXSIZE 32
static char *version = "delta v0.1, written by Olaf Matthes <olaf.matthes(a)gmx.de>";
typedef struct delta
{
t_object x_ob;
t_outlet *x_out; /* result */
t_int x_order; /* 1st or second order */
t_int x_clearflag;
t_float x_delta; /* the result */
t_float x_prev; /* previous value */
t_float x_prev2; /* value previous to previous value */
} t_delta;
static void delta_clear(t_delta *x)
{
if(x->x_order == 2)
x->x_clearflag = 2;
else
x->x_clearflag = 1;
x->x_delta = 0;
}
static void delta_bang(t_delta *x)
{
outlet_float(x->x_out, x->x_delta);
}
static void delta_float(t_delta *x, t_floatarg f)
{
if(x->x_order != 2) /* first order */
{
if(x->x_clearflag)
{
x->x_prev = f;
x->x_delta = 0;
x->x_clearflag = 0;
}
else
{
x->x_delta = f - x->x_prev;
x->x_prev = f;
}
}
else
{
switch(x->x_clearflag)
{
case 0:
x->x_delta = f - 2*x->x_prev + x->x_prev2;
x->x_prev2 = x->x_prev;
x->x_prev = f;
break;
case 1:
x->x_prev = f;
x->x_clearflag--;
break;
case 2:
x->x_prev2 = f;
x->x_clearflag--;
break;
}
}
delta_bang(x);
}
static t_class *delta_class;
static void *delta_new(t_floatarg f)
{
int i;
t_delta *x = (t_delta *)pd_new(delta_class);
x->x_out = outlet_new(&x->x_ob, gensym("float"));
x->x_order = (int)f;
if(x->x_order == 2)
x->x_clearflag = 2;
else
x->x_clearflag = 1;
x->x_delta = 0;
return (void *)x;
}
#ifndef MAXLIB
void delta_setup(void)
{
delta_class = class_new(gensym("delta"), (t_newmethod)delta_new,
0, sizeof(t_delta), 0, A_DEFFLOAT, 0);
#else
void maxlib_delta_setup(void)
{
delta_class = class_new(gensym("maxlib_delta"), (t_newmethod)delta_new,
0, sizeof(t_delta), 0, A_DEFFLOAT, 0);
#endif
class_addfloat(delta_class, delta_float);
class_addbang(delta_class, (t_method)delta_bang);
class_addmethod(delta_class, (t_method)delta_clear, gensym("clear"), 0);
class_sethelpsymbol(delta_class, gensym("maxlib/help-delta.pd"));
#ifndef MAXLIB
class_sethelpsymbol(delta_class, gensym("help-delta.pd"));
post(version);
#else
class_addcreator((t_newmethod)delta_new, gensym("delta"), A_DEFFLOAT, 0);
class_sethelpsymbol(delta_class, gensym("maxlib/help-delta.pd"));
#endif
}
--- NEW FILE: dist.c ---
/* -------------------------- dist ------------------------------------------ */
/* */
/* Distributes incoming data to a changeable list of receive objects. */
/* Written by Olaf Matthes (olaf.matthes(a)gmx.de) */
/* Get source at http://www.akustische-kunst.org/puredata/maxlib/ */
/* */
/* This program is free software; you can redistribute it and/or */
/* modify it under the terms of the GNU General Public License */
/* as published by the Free Software Foundation; either version 2 */
/* of the License, or (at your option) any later version. */
/* */
/* This program is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
/* GNU General Public License for more details. */
/* */
/* You should have received a copy of the GNU General Public License */
/* along with this program; if not, write to the Free Software */
/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/* */
/* Based on PureData by Miller Puckette and others. */
/* */
/* ---------------------------------------------------------------------------- */
/*
connect <symbol list>: store receive objects in list of receivers
disconnect <symbol list>: remove objects from list of receivers
clear: clear list of receivers
send <anything>: send anything to all receives named in the list of receivers */
#include "m_pd.h"
#include <string.h>
#include <stdio.h>
#define MAX_REC 64 /* maximum number of receive objects */
#define MAX_ARG 32 /* maximum number of arguments to pass on */
static char *version = "dist v0.1, written by Olaf Matthes <olaf.matthes(a)gmx.de>";
static t_class *dist_class;
typedef struct _dist
{
t_object x_obj;
t_symbol *x_sym[MAX_REC]; /* names of receiving objects */
t_int x_rec; /* current number of receiving objects */
t_int x_verbose; /* set to 0 to turn off detailed output in Pd window */
} t_dist;
static void dist_bang(t_dist *x)
{
int i;
for(i = 0; i <= x->x_rec; i++)
{
if (x->x_sym[i]->s_thing) pd_bang(x->x_sym[i]->s_thing);
}
}
static void dist_float(t_dist *x, t_float f)
{
int i;
for(i = 0; i <= x->x_rec; i++)
{
if (x->x_sym[i]->s_thing) pd_float(x->x_sym[i]->s_thing, f);
}
}
static void dist_symbol(t_dist *x, t_symbol *s)
{
int i;
for(i = 0; i <= x->x_rec; i++)
{
if (x->x_sym[i]->s_thing) pd_symbol(x->x_sym[i]->s_thing, s);
}
}
static void dist_pointer(t_dist *x, t_gpointer *gp)
{
int i;
for(i = 0; i <= x->x_rec; i++)
{
if (x->x_sym[i]->s_thing) pd_pointer(x->x_sym[i]->s_thing, gp);
}
}
static void dist_list(t_dist *x, t_symbol *s, int argc, t_atom *argv)
{
int i;
for(i = 0; i <= x->x_rec; i++)
{
if (x->x_sym[i]->s_thing) pd_list(x->x_sym[i]->s_thing, s, argc, argv);
}
}
static void dist_anything(t_dist *x, t_symbol *s, int argc, t_atom *argv)
{
int i;
for(i = 0; i <= x->x_rec; i++)
{
if (x->x_sym[i]->s_thing) typedmess(x->x_sym[i]->s_thing, s, argc, argv);
}
}
/* send 'anything' to receiver */
static void dist_send(t_dist *x, t_symbol *s, int argc, t_atom *argv)
{
int i;
t_atom av[MAX_ARG]; /* the 'new' t_atom without first element */
t_int ac = argc - 1; /* the 'new' number of arguments */
if(ac > MAX_ARG)
{
post("dist: too many arguments!");
return;
}
for(i = 1; i < argc; i++)
{
av[i - 1] = argv[i]; /* just copy, don't care about types */
}
/* send only argument-part to receivers */
for(i = 0; i <= x->x_rec; i++)
{
if (x->x_sym[i]->s_thing) pd_forwardmess(x->x_sym[i]->s_thing, argc, argv);
}
}
static void dist_connect(t_dist *x, t_symbol *s, int argc, t_atom *argv)
{
int i, j;
int exist;
t_symbol *name;
/* just append every new receive-name to end of list */
for(i = 0; i < argc; i++)
{
exist = 0;
if(x->x_rec == MAX_REC - 1)
{
post("dist: too many connections in use!");
return;
}
name = atom_getsymbolarg(i, argc, argv);
for(j = 0; j <= x->x_rec; j++)
{
/* check if the name already exists */
if(x->x_sym[j] == name)
{
post("dist: \"%s\" already exists in list of receivers", name->s_name);
exist = 1; /* indicate that it _does_ exist */
}
}
/* add it in case it's a new one */
if(!exist)
{
x->x_rec++;
x->x_sym[x->x_rec] = name;
if(x->x_verbose)post("dist: \"%s\" added to list of receivers", x->x_sym[x->x_rec]->s_name);
}
}
}
static void dist_disconnect(t_dist *x, t_symbol *s, int argc, t_atom *argv)
{
/* need to rearrange list in order to get rid of empty entries */
int i, j, k;
int done;
t_symbol *name;
for(i = 0; i < argc; i++)
{
name = atom_getsymbolarg(i, argc, argv); /* the one we're going to remove */
done = 0; /* not yet removed */
for(j = 0; j <= x->x_rec; j++) /* search for it... */
{
if(x->x_sym[j] == name)
{
x->x_rec--;
if(x->x_verbose)post("dist: \"%s\" removed from list of receivers", x->x_sym[j]->s_name);
x->x_sym[j] = NULL; /* delete entry */
/* rearrange list now: move entries to close the gap */
for(k = j; k <= x->x_rec; k++)
{
x->x_sym[k] = x->x_sym[k + 1];
}
done = 1; /* removed successfully */
}
}
if(!done)post("dist: \"%s\" not in list of receivers, ignored", name->s_name);
}
}
static void dist_clear(t_dist *x)
{
int i;
for(i = 0; i < MAX_REC; i++)
{
x->x_sym[i] = NULL;
}
x->x_rec = -1;
}
static void dist_print(t_dist *x)
{
int i;
if(x->x_rec == 0)
{
post("dist: there is one object in receiver list:");
}
else if(x->x_rec > 0)
{
post("dist: there are %d objects in receiver list:", x->x_rec + 1);
}
else
{
post("dist: there are no objects in receiver list");
return;
}
for(i = 0; i <= x->x_rec; i++)
{
post(" \"%s\"", x->x_sym[i]->s_name);
}
}
static void *dist_new(t_symbol *s, int argc, t_atom *argv)
{
int i;
t_dist *x = (t_dist *)pd_new(dist_class);
x->x_rec = -1;
x->x_verbose = 1; /* display info on connect/disconnect */
for(i = 0; i < argc; i++)
{
x->x_sym[i] = atom_getsymbolarg(i, argc, argv);
x->x_rec++;
}
return (x);
}
#ifndef MAXLIB
void dist_setup(void)
{
dist_class = class_new(gensym("dist"), (t_newmethod)dist_new, 0,
sizeof(t_dist), 0, A_GIMME, 0);
#else
void maxlib_dist_setup(void)
{
dist_class = class_new(gensym("maxlib_dist"), (t_newmethod)dist_new, 0,
sizeof(t_dist), 0, A_GIMME, 0);
#endif
class_addcreator((t_newmethod)dist_new, gensym("d"), A_GIMME, 0);
class_addbang(dist_class, dist_bang);
class_addfloat(dist_class, dist_float);
class_addsymbol(dist_class, dist_symbol);
class_addpointer(dist_class, dist_pointer);
class_addlist(dist_class, dist_list);
class_addmethod(dist_class, (t_method)dist_connect, gensym("connect"), A_GIMME, 0);
class_addmethod(dist_class, (t_method)dist_disconnect, gensym("disconnect"), A_GIMME, 0);
class_addmethod(dist_class, (t_method)dist_clear, gensym("clear"), 0);
class_addmethod(dist_class, (t_method)dist_print, gensym("print"), 0);
class_addmethod(dist_class, (t_method)dist_send, gensym("send"), A_GIMME, 0);
class_addanything(dist_class, dist_anything);
#ifndef MAXLIB
class_sethelpsymbol(dist_class, gensym("help-dist.pd"));
post(version);
#else
class_addcreator((t_newmethod)dist_new, gensym("dist"), A_GIMME, 0);
class_sethelpsymbol(dist_class, gensym("maxlib/help-dist.pd"));
#endif
}
--- NEW FILE: scale.c ---
/* ------------------------- scale ------------------------------------------ */
/* */
/* Scales input to lie within an output range. */
/* Written by Olaf Matthes <olaf.matthes(a)gmx.de> */
/* Get source at http://www.akustische-kunst.org/puredata/maxlib/ */
/* */
/* This program is free software; you can redistribute it and/or */
/* modify it under the terms of the GNU General Public License */
/* as published by the Free Software Foundation; either version 2 */
/* of the License, or (at your option) any later version. */
/* */
/* This program is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
/* GNU General Public License for more details. */
/* */
/* You should have received a copy of the GNU General Public License */
/* along with this program; if not, write to the Free Software */
/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/* */
/* Based on PureData by Miller Puckette and others. */
/* */
/* ---------------------------------------------------------------------------- */
#include "m_pd.h"
#include <stdio.h>
#include <math.h>
static char *version = "scale v0.2, written by Olaf Matthes <olaf.matthes(a)gmx.de>";
typedef struct scale
{
t_object x_ob;
t_float x_f; /* current input value */
t_float x_il; /* low border of input range */
t_float x_ih; /* high border of input range */
t_float x_ol; /* low border of output range */
t_float x_oh; /* high border of output range */
t_float x_logcoeff; /* log-coefficient */
t_outlet *x_outlet1; /* result */
} t_scale;
static void scale_float(t_scale *x, t_floatarg f)
{
t_float ir = x->x_ih - x->x_il;
t_float or = x->x_oh - x->x_ol;
double oq;
double result;
double k;
if(ir == 0)
{
post("scale: input range must not be 0");
return;
}
/* we accept an output range of 0 in case someone really wants this */
if(!x->x_logcoeff) /* linear */
{
k = (or / ir);
result = ((f - x->x_il) * k) + x->x_ol;
}
else /* logarythmical scale */
{
oq = x->x_oh / x->x_ol;
// k = (log((double)oq)/log(x->x_logcoeff))/((double)ir);
k = log((double)oq)/((double)ir);
if(x->x_ol)
{
// result = (double)x->x_ol*exp(k*(double)(f - x->x_il)*log(x->x_logcoeff));
result = (double)x->x_ol*exp(k*(double)(f - x->x_il));
}
else
{
/* in case the low output is 0 we have to cheat... */
/* okay, here's the chating: we calculate for a lower out limit
of 1 and remove this shift after the calculation */
result = ((double)(x->x_ol+1)*exp(k*(double)(f - x->x_il)))-1.0;
}
}
x->x_f = f; /* save current input value */
outlet_float(x->x_outlet1, result);
}
static void scale_bang(t_scale *x)
{
scale_float(x, x->x_f); /* recalculate result */
}
static t_class *scale_class;
static void *scale_new(t_floatarg fil, t_floatarg fih, t_floatarg fol, t_floatarg foh, t_floatarg flc)
{
t_scale *x = (t_scale *)pd_new(scale_class);
floatinlet_new(&x->x_ob, &x->x_il);
floatinlet_new(&x->x_ob, &x->x_ih);
floatinlet_new(&x->x_ob, &x->x_ol);
floatinlet_new(&x->x_ob, &x->x_oh);
floatinlet_new(&x->x_ob, &x->x_logcoeff);
x->x_outlet1 = outlet_new(&x->x_ob, gensym("float"));
/* default values taken from Max's scale */
x->x_il = fil;
x->x_ih = fih;
if(!x->x_ih)x->x_ih = 127.0;
x->x_ol = fol;
x->x_oh = foh;
if(!x->x_oh)x->x_oh = 1.0;
x->x_logcoeff = flc;
x->x_f = 0;
return (void *)x;
}
#ifndef MAXLIB
void scale_setup(void)
{
scale_class = class_new(gensym("scale"), (t_newmethod)scale_new,
0, sizeof(t_scale), 0, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0);
class_addfloat(scale_class, scale_float);
class_addbang(scale_class, scale_bang);
class_sethelpsymbol(scale_class, gensym("help-scale.pd"));
post(version);
#else
void maxlib_scale_setup(void)
{
scale_class = class_new(gensym("maxlib_scale"), (t_newmethod)scale_new,
0, sizeof(t_scale), 0, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0);
class_addcreator((t_newmethod)scale_new, gensym("scale"), A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, A_DEFFLOAT, 0);
class_addfloat(scale_class, scale_float);
class_addbang(scale_class, scale_bang);
class_sethelpsymbol(scale_class, gensym("maxlib/help-scale.pd"));
#endif
}
--- NEW FILE: remote.c ---
/* ------------------------ remote ------------------------------------------ */
/* */
/* Send data to receive obejct <name>. */
/* Written by Olaf Matthes (olaf.matthes(a)gmx.de) */
/* Get source at http://www.akustische-kunst.de/puredata/ */
/* */
/* This program is free software; you can redistribute it and/or */
/* modify it under the terms of the GNU General Public License */
/* as published by the Free Software Foundation; either version 2 */
/* of the License, or (at your option) any later version. */
/* */
/* This program is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
/* GNU General Public License for more details. */
/* */
/* You should have received a copy of the GNU General Public License */
/* along with this program; if not, write to the Free Software */
/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/* */
/* Based on PureData by Miller Puckette and others. */
/* */
/* ---------------------------------------------------------------------------- */
#include "m_pd.h"
#include <string.h>
#include <stdio.h>
#define MAX_REC 64 /* maximum number of receive objects */
#define MAX_ARG 64 /* maximum number of arguments to pass on */
static char *version = "remote v0.2, written by Olaf Matthes <olaf.matthes(a)gmx.de>";
static t_class *remote_class;
typedef struct _remote
{
t_object x_obj;
t_symbol *x_prefix;
t_int x_prepend;
} t_remote;
/* send 'anything' to receiver */
static void remote_anything(t_remote *x, t_symbol *s, int argc, t_atom *argv)
{
int i;
t_atom av[MAX_ARG]; /* the 'new' t_atom without first element */
t_int ac = argc - 1; /* the 'new' number of arguments */
char mysym[MAXPDSTRING];
t_symbol *target;
if(argc < 1) /* need <name> <data> */
{
post("remote: too few arguments!");
return;
}
if(ac > MAX_ARG)
{
post("remote: too many arguments!");
return;
}
for(i = 1; i < argc; i++)
{
av[i - 1] = argv[i]; /* just copy, don't care about types */
}
/* send only argument-part to receivers */
if(x->x_prepend)
{
sprintf(mysym,"%s%s", x->x_prefix->s_name, s->s_name);
target = gensym(mysym);
if (target->s_thing) pd_forwardmess(target->s_thing, argc, argv);
}
else
if (s->s_thing) pd_forwardmess(s->s_thing, argc, argv);
}
static void *remote_new(t_symbol *s)
{
t_remote *x = (t_remote *)pd_new(remote_class);
x->x_prefix = s;
if(x->x_prefix) x->x_prepend = 1;
else x->x_prepend = 0;
return (x);
}
#ifndef MAXLIB
void remote_setup(void)
{
remote_class = class_new(gensym("remote"), (t_newmethod)remote_new, 0,
sizeof(t_remote), 0, A_DEFSYM, 0);
class_addanything(remote_class, remote_anything);
class_sethelpsymbol(remote_class, gensym("help-remote.pd"));
post(version);
}
#else
void maxlib_remote_setup(void)
{
remote_class = class_new(gensym("maxlib_remote"), (t_newmethod)remote_new, 0,
sizeof(t_remote), 0, A_DEFSYM, 0);
class_addcreator((t_newmethod)remote_new, gensym("remote"), A_DEFSYM, 0);
class_addanything(remote_class, remote_anything);
class_sethelpsymbol(remote_class, gensym("maxlib/help-remote.pd"));
}
#endif
--- NEW FILE: fifo.c ---
/* ---------------------------- fifo ------------------------------------------ */
/* */
/* Fifo buffer of floats, empties itselfe on every bang (in order of coming in) */
/* Written by Olaf Matthes (olaf.matthes(a)gmx.de) */
/* Get source at http://www.akustische-kunst.org/puredata/maxlib/ */
/* */
/* This program is free software; you can redistribute it and/or */
/* modify it under the terms of the GNU General Public License */
/* as published by the Free Software Foundation; either version 2 */
/* of the License, or (at your option) any later version. */
/* */
/* This program is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
/* GNU General Public License for more details. */
/* */
/* You should have received a copy of the GNU General Public License */
/* along with this program; if not, write to the Free Software */
/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/* */
/* Based on PureData by Miller Puckette and others. */
/* */
/* Fifi-code based St. Rainstick fifi.c for Max, */
/* copyright St. Rainstick, Amsterdam 1995 */
/* */
/* ---------------------------------------------------------------------------- */
#include "m_pd.h"
static char *version = "fifo v0.1, written by Olaf Matthes <olaf.matthes(a)gmx.de>";
typedef struct fifo
{
t_object d_ob;
t_float *getal;
t_int count, end, size;
t_outlet *out;
}t_fifo;
static t_class *fifo_class;
static void fifo_int(t_fifo *x, t_floatarg n)
{
x->getal[x->count] = n;
x->count = (x->count + 1) % x->size;
}
static void fifo_bang(t_fifo *x)
{
if (x->end != x->count){
outlet_float(x->out,x->getal[x->end]);
x->end = (x->end + 1) % x->size;
}
}
static void fifo_free(t_fifo *x)
{
freebytes(x->getal, x->size * sizeof(t_float));
}
static void *fifo_new(t_floatarg n)
{
t_fifo *x = (t_fifo *)pd_new(fifo_class);
if (n<10) n = 10;
x->size = (t_int)n;
x->end = 0;
x->count = 0;
x->getal = (t_float *)getbytes(x->size * sizeof(t_float));
x->out = outlet_new(&x->d_ob, gensym("float"));
return (x);
}
#ifndef MAXLIB
void fifo_setup(void)
{
fifo_class = class_new(gensym("fifo"), (t_newmethod)fifo_new,
(t_method)fifo_free, sizeof(t_fifo), 0, A_DEFFLOAT, 0);
class_addfloat(fifo_class, fifo_int);
class_addbang(fifo_class, fifo_bang);
class_sethelpsymbol(fifo_class, gensym("help-fifo.pd"));
post(version);
}
#else
void maxlib_fifo_setup(void)
{
fifo_class = class_new(gensym("maxlib_fifo"), (t_newmethod)fifo_new,
(t_method)fifo_free, sizeof(t_fifo), 0, A_DEFFLOAT, 0);
class_addcreator((t_newmethod)fifo_new, gensym("fifo"), A_DEFFLOAT, 0);
class_addfloat(fifo_class, fifo_int);
class_addbang(fifo_class, fifo_bang);
class_sethelpsymbol(fifo_class, gensym("maxlib/help-fifo.pd"));
}
#endif
--- NEW FILE: cauchy.c ---
/* ---------------------------- rand_cauchy ----------------------------------- */
/* */
/* rand_cauchy generates a Cauchy distributed random variable. */
/* Written by Olaf Matthes (olaf.matthes(a)gmx.de) */
/* Based on code found in Dodge/Jerse "Computer Music" */
/* Get source at http://www.akustische-kunst.org/puredata/maxlib/ */
/* */
/* This program is free software; you can redistribute it and/or */
/* modify it under the terms of the GNU General Public License */
/* as published by the Free Software Foundation; either version 2 */
/* of the License, or (at your option) any later version. */
/* */
/* This program is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
/* GNU General Public License for more details. */
/* */
/* You should have received a copy of the GNU General Public License */
/* along with this program; if not, write to the Free Software */
/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/* */
/* Based on PureData by Miller Puckette and others. */
/* */
/* ---------------------------------------------------------------------------- */
#include "m_pd.h"
#include <stdlib.h>
#include <time.h>
#include <math.h>
#define fran() (t_float)rand()/(t_float)RAND_MAX
#ifndef M_PI
#define M_PI 3.1415927
#endif
static char *version = "cauchy v0.1, generates a Cauchy distributed random variable\n"
" with a spread governed by to parameter 'aplha',\n"
" written by Olaf Matthes <olaf.matthes(a)gmx.de>";
/* -------------------------- rand_cauchy ------------------------------ */
static t_class *rand_cauchy_class;
typedef struct _rand_cauchy
{
t_object x_obj;
t_float x_alpha;
} t_rand_cauchy;
static void *rand_cauchy_new(t_floatarg f)
{
t_rand_cauchy *x = (t_rand_cauchy *)pd_new(rand_cauchy_class);
srand( (unsigned)time( NULL ) );
floatinlet_new(&x->x_obj, &x->x_alpha);
outlet_new(&x->x_obj, &s_float);
x->x_alpha = f;
return (x);
}
static void rand_cauchy_bang(t_rand_cauchy *x)
{
t_float u;
do
{
u = fran();
}
while(u == 0.5);
u *= M_PI;
outlet_float(x->x_obj.ob_outlet, x->x_alpha*tan(u));
}
#ifndef MAXLIB
void cauchy_setup(void)
{
rand_cauchy_class = class_new(gensym("cauchy"), (t_newmethod)rand_cauchy_new, 0,
sizeof(t_rand_cauchy), 0, A_DEFFLOAT, 0);
class_addbang(rand_cauchy_class, rand_cauchy_bang);
class_sethelpsymbol(rand_cauchy_class, gensym("help-cauchy.pd"));
post(version);
#else
void maxlib_cauchy_setup(void)
{
rand_cauchy_class = class_new(gensym("maxlib_cauchy"), (t_newmethod)rand_cauchy_new, 0,
sizeof(t_rand_cauchy), 0, A_DEFFLOAT, 0);
class_addbang(rand_cauchy_class, rand_cauchy_bang);
class_addcreator((t_newmethod)rand_cauchy_new, gensym("cauchy"), A_DEFFLOAT, 0);
class_sethelpsymbol(rand_cauchy_class, gensym("maxlib/help-cauchy.pd"));
#endif
}
--- NEW FILE: sync.c ---
/* ------------------------- sync ------------------------------------------- */
/* */
/* syncronises outputs depending on inputs. */
/* Written by Olaf Matthes <olaf.matthes(a)gmx.de> */
/* Based on 'sync' from jMax. */
/* Get source at http://www.akustische-kunst.org/puredata/maxlib/ */
/* */
/* This program is free software; you can redistribute it and/or */
/* modify it under the terms of the GNU General Public License */
/* as published by the Free Software Foundation; either version 2 */
/* of the License, or (at your option) any later version. */
/* */
/* This program is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
/* GNU General Public License for more details. */
/* */
/* You should have received a copy of the GNU General Public License */
/* along with this program; if not, write to the Free Software */
/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/* */
/* Based on PureData by Miller Puckette and others. */
/* */
/* ---------------------------------------------------------------------------- */
#include "m_pd.h"
#include <stdio.h>
#include <math.h>
#define SYNC_MAX_SIZE (int)(sizeof(unsigned int) * 8)
static char *version = "sync v0.1, written by Olaf Matthes <olaf.matthes(a)gmx.de>\n"
" based on sync from jMax";
typedef struct sync
{
t_object x_ob;
t_float x_min; /* low border of input range */
t_float x_max; /* high border of input range */
t_outlet *x_outlet[SYNC_MAX_SIZE];
t_int x_n;
unsigned int x_trigger; /* control bits: trigger on input at given inlets */
unsigned int x_require; /* control bits: require input on given inlets */
unsigned int x_reset; /* control bits: reset memory of given inputs after on each input */
unsigned int x_wait; /* status bits: wait for input at given inlet before output */
t_atom x_a[SYNC_MAX_SIZE];
enum {mode_all, mode_select} mode;
} t_sync;
typedef struct proxy
{
t_object obj;
t_int index; /* number of proxy inlet(s) */
t_sync *x; /* we'll put the other struct in here */
} t_proxy;
static void sync_output(t_sync *x)
{
int i;
for(i=x->x_n-1; i>=0; i--)
if(x->x_a[i].a_type != A_SEMI)
outlet_list(x->x_outlet[i], NULL, 1, x->x_a + i);
}
static void sync_input(t_proxy *p, t_symbol *s, int ac, t_atom *at)
{
t_sync *x = (t_sync *)(p->x);
int winlet = p->index;
if(ac)
{
unsigned int bit = 1 << winlet;
x->x_a[winlet] = at[0];
x->x_wait &= ~bit;
if(!x->x_wait && (x->x_trigger & bit))
{
sync_output(x);
x->x_wait |= x->x_reset & x->x_require;
}
}
}
static void sync_float_input(t_proxy *p, t_floatarg f)
{
t_sync *x = (t_sync *)(p->x);
int winlet = p->index;
{
unsigned int bit = 1 << winlet;
SETFLOAT(x->x_a + winlet, f);
x->x_wait &= ~bit;
if(!x->x_wait && (x->x_trigger & bit))
{
sync_output(x);
x->x_wait |= x->x_reset & x->x_require;
}
}
}
static void sync_set_bits(unsigned int *bits, int n, t_atom *at, int sign)
{
if(at->a_type == A_SYMBOL)
{
t_symbol *mode = atom_getsymbol(at);
if(mode == gensym("all"))
*bits = (1 << n) - 1;
else if(mode == gensym("none"))
*bits = 0;
}
else if(at->a_type == A_FLOAT)
{
int in = (int)atom_getfloat(at) * sign;
if(in >= 0 && in < n)
*bits = 1 << in;
}
else if(at->a_type == A_GIMME)
{
int size = n;
int i;
*bits = 0;
for(i=0; i<size; i++)
{
if(at[i].a_type == A_FLOAT)
{
int in = atom_getfloatarg(i, size, at) * sign;
if(in >= 0 && in < n)
*bits |= 1 << in;
}
}
}
}
static void sync_set_trigger(t_sync *x, t_symbol *s, int ac, t_atom *at)
{
sync_set_bits(&x->x_trigger, x->x_n, at, 1);
}
static void sync_set_require(t_sync *x, t_symbol *s, int ac, t_atom *at)
{
unsigned int once = 0;
sync_set_bits(&x->x_require, x->x_n, at, 1);
sync_set_bits(&once, x->x_n, at, -1);
x->x_reset = ~once;
x->x_wait = x->x_require | once;
}
static void sync_set_mode(t_sync *x, t_symbol *mode)
{
if(mode == gensym("any"))
{
x->x_trigger = (1 << x->x_n) - 1;
x->x_reset = 0;
x->x_require = 0;
}
else if(mode == gensym("all"))
x->x_trigger = x->x_require = x->x_reset = x->x_wait = (1 << x->x_n) - 1;
else if(mode == gensym("left"))
{
x->x_trigger = 1;
x->x_reset = 0;
x->x_require = 0;
}
else if(mode == gensym("right"))
{
x->x_trigger = (1 << (x->x_n - 1));
x->x_reset = 0;
x->x_require = 0;
}
x->x_wait = x->x_require;
}
static void sync_float(t_sync *x, t_floatarg f)
{
unsigned int bit = 1 << 0;
SETFLOAT(x->x_a, f);
x->x_wait &= ~bit;
if(!x->x_wait && (x->x_trigger & bit))
{
sync_output(x);
x->x_wait |= x->x_reset & x->x_require;
}
}
static t_class *sync_class;
static t_class *proxy_class;
static void *sync_new(t_symbol *s, int ac, t_atom *at)
{
int n = 0;
int i;
t_sync *x = (t_sync *)pd_new(sync_class);
t_proxy *inlet[SYNC_MAX_SIZE];
/* void state - we fill with SEMI and treat this as 'void' */
for(i=0; i<SYNC_MAX_SIZE; i++)
SETSEMI(x->x_a + i);
if(ac == 1)
{
if(at->a_type == A_FLOAT)
{
n = atom_getfloat(at);
if(n < 2)
n = 2;
else if(n > SYNC_MAX_SIZE)
n = SYNC_MAX_SIZE;
}
else
{
post("sync: wrong argument");
return (0);
}
}
else if(ac > 1)
{
if(ac > SYNC_MAX_SIZE)
ac = SYNC_MAX_SIZE;
n = ac;
for(i=0; i<n; i++)
x->x_a[i] = at[i];
}
x->x_n = n;
x->x_trigger = x->x_require = x->x_reset = x->x_wait = (1 << n) - 1;
x->x_outlet[0] = outlet_new(&x->x_ob, gensym("list"));
for(i=1; i<n; i++)
{
inlet[i] = (t_proxy *)pd_new(proxy_class); /* create the proxy inlet */
inlet[i]->x = x; /* make t_sync *x visible to the proxy inlets */
inlet[i]->index = i; /* remember it's number */
/* it belongs to the object t_sync but the destination is t_proxy */
inlet_new(&x->x_ob, &inlet[i]->obj.ob_pd, 0,0);
x->x_outlet[i] = outlet_new(&x->x_ob, gensym("list"));
}
return (void *)x;
}
#ifndef MAXLIB
void sync_setup(void)
{
sync_class = class_new(gensym("sync"), (t_newmethod)sync_new,
0, sizeof(t_sync), 0, A_GIMME, 0);
#else
void maxlib_sync_setup(void)
{
sync_class = class_new(gensym("maxlib_sync"), (t_newmethod)sync_new,
0, sizeof(t_sync), 0, A_GIMME, 0);
#endif
/* a class for the proxy inlet: */
proxy_class = class_new(gensym("maxlib_sync_proxy"), NULL, NULL, sizeof(t_proxy),
CLASS_PD|CLASS_NOINLET, A_NULL);
class_addfloat(proxy_class, sync_float_input);
class_addanything(proxy_class, sync_input);
class_addfloat(sync_class, sync_float);
class_addmethod(sync_class, (t_method)sync_set_trigger, gensym("trigger"), A_GIMME, 0);
class_addmethod(sync_class, (t_method)sync_set_require, gensym("require"), A_GIMME, 0);
class_addmethod(sync_class, (t_method)sync_set_mode, gensym("mode"), A_SYMBOL, 0);
#ifndef MAXLIB
class_sethelpsymbol(sync_class, gensym("help-sync.pd"));
post(version);
#else
class_addcreator((t_newmethod)sync_new, gensym("sync"), A_GIMME, 0);
class_sethelpsymbol(sync_class, gensym("maxlib/help-sync.pd"));
#endif
}
--- NEW FILE: listfifo.c ---
/* ---------------------------- listfifo -------------------------------------- */
/* */
/* Fifo buffer of lists, empties itselfe on every bang (in order of coming in) */
/* Written by Olaf Matthes (olaf.matthes(a)gmx.de) */
/* Get source at http://www.akustische-kunst.org/puredata/maxlib/ */
/* */
/* This program is free software; you can redistribute it and/or */
/* modify it under the terms of the GNU General Public License */
/* as published by the Free Software Foundation; either version 2 */
/* of the License, or (at your option) any later version. */
/* */
/* This program is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
/* GNU General Public License for more details. */
/* */
/* You should have received a copy of the GNU General Public License */
/* along with this program; if not, write to the Free Software */
/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/* */
/* Based on PureData by Miller Puckette and others. */
/* */
/* ---------------------------------------------------------------------------- */
#include "m_pd.h"
#define MAX_ELEM 256 /* maximum number of list elements to pass on */
static char *version = "listfifo v0.1, written by Olaf Matthes <olaf.matthes(a)gmx.de>";
typedef struct listfifo
{
t_object d_ob;
t_atom *getal; /* stores the list values */
t_int *getsize; /* stores the number of elements in list */
t_int count, end, size;
t_outlet *out;
}t_listfifo;
static t_class *listfifo_class;
static void listfifo_list(t_listfifo *x, t_symbol *s, int argc, t_atom *argv)
{
int i;
if(argc > MAX_ELEM)
{
post("listfifo: to many arguments in list, ignored");
return;
}
for(i = 0; i < argc; i++)
x->getal[(x->count * MAX_ELEM) + i] = argv[i];
x->getsize[x->count] = argc;
x->count = (x->count + 1) % x->size;
// post("got %d elements", argc);
}
static void listfifo_bang(t_listfifo *x)
{
// post("count = %d, end = %d", x->count, x->end);
if (x->end != x->count){
outlet_list(x->out, NULL, x->getsize[x->end], x->getal+(x->end * MAX_ELEM));
x->end = (x->end + 1) % x->size;
}
}
static void listfifo_free(t_listfifo *x)
{
freebytes(x->getsize, x->size * sizeof(t_int));
freebytes(x->getal, x->size * sizeof(t_float) * MAX_ELEM);
}
static void *listfifo_new(t_floatarg n)
{
int i;
t_listfifo *x = (t_listfifo *)pd_new(listfifo_class);
if (n<10) n = 10;
x->size = (t_int)n;
x->end = 0;
x->count = 0;
x->getsize = (t_int *)getbytes(x->size * sizeof(t_int));
x->getal = (t_atom *)getbytes(x->size * sizeof(t_atom) * MAX_ELEM);
x->out = outlet_new(&x->d_ob, gensym("list"));
return (x);
}
#ifndef MAXLIB
void listfifo_setup(void)
{
listfifo_class = class_new(gensym("listfifo"), (t_newmethod)listfifo_new,
(t_method)listfifo_free, sizeof(t_listfifo), 0, A_DEFFLOAT, 0);
class_addbang(listfifo_class, listfifo_bang);
class_addlist(listfifo_class, listfifo_list);
class_sethelpsymbol(listfifo_class, gensym("help-listfifo.pd"));
post(version);
}
#else
void maxlib_listfifo_setup(void)
{
listfifo_class = class_new(gensym("maxlib_listfifo"), (t_newmethod)listfifo_new,
(t_method)listfifo_free, sizeof(t_listfifo), 0, A_DEFFLOAT, 0);
class_addcreator((t_newmethod)listfifo_new, gensym("listfifo"), A_DEFFLOAT, 0);
class_addbang(listfifo_class, listfifo_bang);
class_addlist(listfifo_class, listfifo_list);
class_sethelpsymbol(listfifo_class, gensym("maxlib/help-listfifo.pd"));
}
#endif
--- NEW FILE: netclient.c ---
/* -------------------------- netclient ------------------------------------- */
/* */
/* Extended 'netsend', connects to 'netserver'. */
/* Uses child thread to connect to server. Thus needs pd0.35-test17 or later. */
/* Written by Olaf Matthes (olaf.matthes(a)gmx.de) */
/* Get source at http://www.akustische-kunst.org/puredata/maxlib/ */
/* */
/* This program is free software; you can redistribute it and/or */
/* modify it under the terms of the GNU General Public License */
/* as published by the Free Software Foundation; either version 2 */
/* of the License, or (at your option) any later version. */
/* */
/* This program is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
/* GNU General Public License for more details. */
/* */
/* You should have received a copy of the GNU General Public License */
/* along with this program; if not, write to the Free Software */
/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/* */
/* Based on PureData by Miller Puckette and others. */
/* */
/* ---------------------------------------------------------------------------- */
/* Changes: use circular message buffer for receive */
/* using pollfunction instead of clock (suggested by HCS) */
#ifdef PD_0_37
#include "m_pd.h"
#include "s_stuff.h"
#endif
#include "m_imp.h"
#include <sys/types.h>
#include <string.h>
#include <pthread.h>
#ifdef UNIX
#include <sys/time.h>
#include <sys/socket.h>
#include <sys/errno.h>
#include <netinet/in.h>
#include <netdb.h>
#include <stdio.h>
#include <unistd.h>
#define SOCKET_ERROR -1
#else
#include <winsock.h>
#endif
#define INBUFSIZE 4096 /* maximum numbers of characters to read */
static char *version = "netclient v0.3, written by Olaf Matthes <olaf.matthes(a)gmx.de>";
static t_class *netclient_class;
static t_binbuf *inbinbuf;
typedef struct _netclient
{
t_object x_obj;
t_clock *x_clock;
t_outlet *x_outdata;
t_outlet *x_outconnect;
int x_fd;
char *x_hostname;
int x_connectstate;
int x_port;
int x_protocol;
char x_inbuf[INBUFSIZE]; /* circular message buffer for received data */
int x_intail;
int x_inhead;
/* multithread stuff */
pthread_t x_threadid; /* id of child thread */
pthread_attr_t x_threadattr; /* attributes of child thread */
} t_netclient;
#ifdef USE_CIRCULAR
static t_binbuf *inbinbuf;
#endif
/* one lonlely prototype */
static void netclient_rcv(t_netclient *x);
/* get's called when connection has been made */
static void netclient_tick(t_netclient *x)
{
outlet_float(x->x_outconnect, 1);
/* add pollfunction for checking for input */
sys_addpollfn(x->x_fd, (t_fdpollfn)netclient_rcv, x);
}
static void *netclient_child_connect(void *w)
{
t_netclient *x = (t_netclient*) w;
struct sockaddr_in server;
struct hostent *hp;
int sockfd;
int portno = x->x_port;
if (x->x_fd >= 0)
{
error("netclient_connect: already connected");
return (x);
}
/* create a socket */
sockfd = socket(AF_INET, x->x_protocol, 0);
#if 0
fprintf(stderr, "send socket %d\n", sockfd);
#endif
if (sockfd < 0)
{
sys_sockerror("socket");
return (x);
}
/* connect socket using hostname provided in command line */
server.sin_family = AF_INET;
hp = gethostbyname(x->x_hostname);
if (hp == 0)
{
post("bad host?\n");
return (x);
}
memcpy((char *)&server.sin_addr, (char *)hp->h_addr, hp->h_length);
/* assign client port number */
server.sin_port = htons((u_short)portno);
post("connecting to port %d", portno);
/* try to connect */
if (connect(sockfd, (struct sockaddr *) &server, sizeof (server)) < 0)
{
sys_sockerror("connecting stream socket");
sys_closesocket(sockfd);
return (x);
}
x->x_fd = sockfd;
/* outlet_float is not threadsafe ! */
// outlet_float(x->x_obj.ob_outlet, 1);
x->x_connectstate = 1;
/* use callback instead to set outlet */
clock_delay(x->x_clock, 0);
return (x);
}
static void netclient_connect(t_netclient *x, t_symbol *hostname,
t_floatarg fportno)
{
/* we get hostname and port and pass them on
to the child thread that establishes the connection */
x->x_hostname = hostname->s_name;
x->x_port = fportno;
x->x_connectstate = 0;
/* start child thread */
if(pthread_create( &x->x_threadid, &x->x_threadattr, netclient_child_connect, x) < 0)
post("netclient: could not create new thread");
}
static void netclient_disconnect(t_netclient *x)
{
if (x->x_fd >= 0)
{
sys_rmpollfn(x->x_fd);
sys_closesocket(x->x_fd);
x->x_fd = -1;
x->x_connectstate = 0;
outlet_float(x->x_outconnect, 0);
}
}
static void netclient_send(t_netclient *x, t_symbol *s, int argc, t_atom *argv)
{
if (x->x_fd >= 0)
{
t_binbuf *b = binbuf_new();
char *buf, *bp;
int length, sent;
t_atom at;
binbuf_add(b, argc, argv);
SETSEMI(&at);
binbuf_add(b, 1, &at);
binbuf_gettext(b, &buf, &length);
for (bp = buf, sent = 0; sent < length;)
{
static double lastwarntime;
static double pleasewarn;
double timebefore = sys_getrealtime();
int res = send(x->x_fd, buf, length-sent, 0);
double timeafter = sys_getrealtime();
int late = (timeafter - timebefore > 0.005);
if (late || pleasewarn)
{
if (timeafter > lastwarntime + 2)
{
post("netclient blocked %d msec",
(int)(1000 * ((timeafter - timebefore) + pleasewarn)));
pleasewarn = 0;
lastwarntime = timeafter;
}
else if (late) pleasewarn += timeafter - timebefore;
}
if (res <= 0)
{
sys_sockerror("netclient");
netclient_disconnect(x);
break;
}
else
{
sent += res;
bp += res;
}
}
t_freebytes(buf, length);
binbuf_free(b);
}
else error("netclient: not connected");
}
/* this is in a separately called subroutine so that the buffer isn't
sitting on the stack while the messages are getting passed. */
static int netclient_doread(t_netclient *x)
{
char messbuf[INBUFSIZE], *bp = messbuf;
int indx;
int inhead = x->x_inhead;
int intail = x->x_intail;
char *inbuf = x->x_inbuf;
if (intail == inhead) return (0);
for (indx = intail; indx != inhead; indx = (indx+1)&(INBUFSIZE-1))
{
char c = *bp++ = inbuf[indx];
if (c == ';' && (!indx || inbuf[indx-1] != '\\'))
{
intail = (indx+1)&(INBUFSIZE-1);
binbuf_text(inbinbuf, messbuf, bp - messbuf);
x->x_inhead = inhead;
x->x_intail = intail;
return (1);
}
}
return (0);
}
static void netclient_rcv(t_netclient *x)
{
int fd = x->x_fd;
int ret;
char resp[INBUFSIZE];
fd_set readset;
fd_set exceptset;
struct timeval ztout;
/* output data */
t_binbuf *binbuf;
t_atom messbuf[1024];
int msg, natom;
t_atom *at;
int i;
if(x->x_connectstate)
{
/* check if we can read/write from/to the socket */
FD_ZERO(&readset);
FD_ZERO(&exceptset);
FD_SET(fd, &readset );
FD_SET(fd, &exceptset );
ztout.tv_sec = 0;
ztout.tv_usec = 0;
ret = select(fd+1, &readset, NULL, &exceptset, &ztout);
if(ret < 0)
{
error("netclient: can not read from socket");
sys_closesocket(fd);
return;
}
if(FD_ISSET(fd, &readset) || FD_ISSET(fd, &exceptset))
{
int readto = (x->x_inhead >= x->x_intail ? INBUFSIZE : x->x_intail-1);
ret = recv(fd, x->x_inbuf + x->x_inhead, readto - x->x_inhead, 0);
if (ret < 0)
{
sys_sockerror("recv");
sys_rmpollfn(fd);
sys_closesocket(fd);
}
else if (ret == 0)
{
post("netclient: connection closed on socket %d", fd);
sys_rmpollfn(fd);
sys_closesocket(fd);
}
else
{
x->x_inhead += ret;
if (x->x_inhead >= INBUFSIZE) x->x_inhead = 0;
while (netclient_doread(x))
{
/* output binbuf */
natom = binbuf_getnatom(inbinbuf); /* get number of atoms */
at = binbuf_getvec(inbinbuf); /* get the atoms */
/* now split it into several parts at every A_SEMI because
we probably received more than one message at a time */
for (msg = 0; msg < natom;)
{
int emsg;
for (emsg = msg; emsg < natom && at[emsg].a_type != A_COMMA
&& at[emsg].a_type != A_SEMI; emsg++);
if (emsg > msg)
{
int ii;
for (ii = msg; ii < emsg; ii++)
if (at[ii].a_type == A_DOLLAR || at[ii].a_type == A_DOLLSYM)
{
pd_error(x, "netserver: -- got dollar sign in message");
goto nodice;
}
if (at[msg].a_type == A_FLOAT)
{
if (emsg > msg + 1)
outlet_list(x->x_outdata, 0, emsg-msg, at + msg);
else outlet_float(x->x_outdata, at[msg].a_w.w_float);
}
else if (at[msg].a_type == A_SYMBOL)
outlet_anything(x->x_outdata, at[msg].a_w.w_symbol,
emsg-msg-1, at + msg + 1);
}
nodice:
msg = emsg + 1;
}
}
}
}
}
else post("netclient: not connected");
}
static void *netclient_new(t_floatarg udpflag)
{
t_netclient *x = (t_netclient *)pd_new(netclient_class);
x->x_outdata = outlet_new(&x->x_obj, &s_anything); /* received data */
x->x_outconnect = outlet_new(&x->x_obj, &s_float); /* connection state */
x->x_clock = clock_new(x, (t_method)netclient_tick);
inbinbuf = binbuf_new();
x->x_fd = -1;
x->x_protocol = (udpflag != 0 ? SOCK_DGRAM : SOCK_STREAM);
/* prepare child thread */
if(pthread_attr_init(&x->x_threadattr) < 0)
post("netclient: warning: could not prepare child thread" );
if(pthread_attr_setdetachstate(&x->x_threadattr, PTHREAD_CREATE_DETACHED) < 0)
post("netclient: warning: could not prepare child thread" );
return (x);
}
static void netclient_free(t_netclient *x)
{
netclient_disconnect(x);
clock_free(x->x_clock);
binbuf_free(inbinbuf);
}
#ifndef MAXLIB
void netclient_setup(void)
{
netclient_class = class_new(gensym("netclient"), (t_newmethod)netclient_new,
(t_method)netclient_free,
sizeof(t_netclient), 0, A_DEFFLOAT, 0);
class_addmethod(netclient_class, (t_method)netclient_connect, gensym("connect"), A_SYMBOL, A_FLOAT, 0);
class_addmethod(netclient_class, (t_method)netclient_disconnect, gensym("disconnect"), 0);
class_addmethod(netclient_class, (t_method)netclient_send, gensym("send"), A_GIMME, 0);
class_addmethod(netclient_class, (t_method)netclient_rcv, gensym("receive"), 0);
class_addmethod(netclient_class, (t_method)netclient_rcv, gensym("rcv"), 0);
class_sethelpsymbol(netclient_class, gensym("help-netclient.pd"));
post(version);
}
#else
void maxlib_netclient_setup(void)
{
netclient_class = class_new(gensym("maxlib_netclient"), (t_newmethod)netclient_new,
(t_method)netclient_free,
sizeof(t_netclient), 0, A_DEFFLOAT, 0);
class_addcreator((t_newmethod)netclient_new, gensym("netclient"), A_DEFFLOAT, 0);
class_addmethod(netclient_class, (t_method)netclient_connect, gensym("connect"), A_SYMBOL, A_FLOAT, 0);
class_addmethod(netclient_class, (t_method)netclient_disconnect, gensym("disconnect"), 0);
class_addmethod(netclient_class, (t_method)netclient_send, gensym("send"), A_GIMME, 0);
class_addmethod(netclient_class, (t_method)netclient_rcv, gensym("receive"), 0);
class_addmethod(netclient_class, (t_method)netclient_rcv, gensym("rcv"), 0);
class_sethelpsymbol(netclient_class, gensym("maxlib/help-netclient.pd"));
}
#endif
1
0
externals/maxlib HISTORY,1.4,1.5 LICENSE,1.2,1.3 README,1.4,1.5 install.bat,1.2,1.3 makefile,1.7,1.8 maxlib.c,1.5,1.6 maxlib.dsp,1.2,1.3 maxlib.dsw,1.2,1.3 maxlib.pd_darwin,1.1.1.1,NONE
by Hans-Christoph Steiner 20 Mar '04
by Hans-Christoph Steiner 20 Mar '04
20 Mar '04
Update of /cvsroot/pure-data/externals/maxlib
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv2641
Added Files:
HISTORY LICENSE README install.bat makefile maxlib.c
maxlib.dsp maxlib.dsw
Removed Files:
maxlib.pd_darwin
Log Message:
things back to Olaf's 1.5.2
--- NEW FILE: maxlib.dsw ---
Microsoft Developer Studio Workspace File, Format Version 6.00
# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
###############################################################################
Project: "maxlib"=.\maxlib.dsp - Package Owner=<4>
Package=<5>
{{{
}}}
Package=<4>
{{{
}}}
###############################################################################
Global:
Package=<5>
{{{
}}}
Package=<3>
{{{
}}}
###############################################################################
--- NEW FILE: maxlib.c ---
/* -------------------------- maxlib ---------------------------------------- */
/* */
/* maxlib :: music analysis extensions library. */
/* Written by Olaf Matthes <olaf.matthes(a)gmx.de> */
/* Get source at http://www.akustische-kunst.org/puredata/maxlib/ */
/* */
/* This program is free software; you can redistribute it and/or */
/* modify it under the terms of the GNU General Public License */
/* as published by the Free Software Foundation; either version 2 */
/* of the License, or (at your option) any later version. */
/* */
/* This program is distributed in the hope that it will be useful, */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
/* GNU General Public License for more details. */
/* */
/* You should have received a copy of the GNU General Public License */
/* along with this program; if not, write to the Free Software */
/* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/* */
/* Based on PureData by Miller Puckette and others. */
/* */
/* ---------------------------------------------------------------------------- */
#ifndef VERSION
#define VERSION "1.5.2"
#endif
#include "m_pd.h"
#ifndef __DATE__
#define __DATE__ "without using a gnu compiler"
#endif
typedef struct _maxlib
{
t_object x_obj;
} t_maxlib;
static t_class* maxlib_class;
/* objects */
void maxlib_allow_setup();
void maxlib_arbran_setup();
void maxlib_arraycopy_setup();
void maxlib_average_setup();
void maxlib_beat_setup();
void maxlib_beta_setup();
void maxlib_bilex_setup();
void maxlib_borax_setup();
void maxlib_cauchy_setup();
void maxlib_chord_setup();
void maxlib_delta_setup();
void maxlib_deny_setup();
void maxlib_dist_setup();
void maxlib_divide_setup();
void maxlib_divmod_setup();
void maxlib_edge_setup();
void maxlib_expo_setup();
void maxlib_fifo_setup();
void maxlib_gauss_setup();
void maxlib_gestalt_setup();
void maxlib_history_setup();
void maxlib_ignore_setup();
void maxlib_iso_setup();
void maxlib_lifo_setup();
void maxlib_limit_setup();
void maxlib_linear_setup();
void maxlib_listfifo_setup();
void maxlib_listfunnel_setup();
void maxlib_match_setup();
void maxlib_minus_setup();
void maxlib_mlife_setup();
void maxlib_multi_setup();
void maxlib_nchange_setup();
void maxlib_netclient_setup();
void maxlib_netdist_setup();
void maxlib_netrec_setup();
void maxlib_netserver_setup();
void maxlib_nroute_setup();
void maxlib_pitch_setup();
void maxlib_plus_setup();
void maxlib_poisson_setup();
void maxlib_pong_setup();
void maxlib_pulse_setup();
void maxlib_remote_setup();
void maxlib_rewrap_setup();
void maxlib_rhythm_setup();
void maxlib_scale_setup();
void maxlib_score_setup();
void maxlib_speedlim_setup();
void maxlib_split_setup();
void maxlib_step_setup();
void maxlib_subst_setup();
void maxlib_sync_setup();
void maxlib_temperature_setup();
void maxlib_tilt_setup();
void maxlib_timebang_setup();
void maxlib_triang_setup();
void maxlib_unroute_setup();
void maxlib_urn_setup();
void maxlib_velocity_setup();
void maxlib_weibull_setup();
void maxlib_wrap_setup();
static void* maxlib_new(t_symbol* s)
{
t_maxlib *x = (t_maxlib *)pd_new(maxlib_class);
return (x);
}
void maxlib_setup(void)
{
maxlib_class = class_new(gensym("maxlib"), (t_newmethod)maxlib_new, 0,
sizeof(t_maxlib), 0,0);
maxlib_allow_setup();
maxlib_arbran_setup();
maxlib_arraycopy_setup();
maxlib_average_setup();
maxlib_beat_setup();
maxlib_beta_setup();
maxlib_bilex_setup();
maxlib_borax_setup();
maxlib_cauchy_setup();
maxlib_chord_setup();
maxlib_delta_setup();
maxlib_deny_setup();
maxlib_dist_setup();
maxlib_divide_setup();
maxlib_divmod_setup();
maxlib_edge_setup();
maxlib_expo_setup();
maxlib_fifo_setup();
maxlib_gauss_setup();
maxlib_gestalt_setup();
maxlib_history_setup();
maxlib_ignore_setup();
maxlib_iso_setup();
maxlib_lifo_setup();
maxlib_limit_setup();
maxlib_linear_setup();
maxlib_listfifo_setup();
maxlib_listfunnel_setup();
maxlib_match_setup();
maxlib_minus_setup();
maxlib_mlife_setup();
maxlib_multi_setup();
maxlib_nchange_setup();
maxlib_netclient_setup();
maxlib_netdist_setup();
maxlib_netrec_setup();
maxlib_netserver_setup();
maxlib_nroute_setup();
maxlib_pitch_setup();
maxlib_plus_setup();
maxlib_poisson_setup();
maxlib_pong_setup();
maxlib_pulse_setup();
maxlib_remote_setup();
maxlib_rewrap_setup();
maxlib_rhythm_setup();
maxlib_scale_setup();
maxlib_score_setup();
maxlib_speedlim_setup();
maxlib_split_setup();
maxlib_step_setup();
maxlib_subst_setup();
maxlib_sync_setup();
maxlib_temperature_setup();
maxlib_tilt_setup();
maxlib_timebang_setup();
maxlib_triang_setup();
maxlib_unroute_setup();
maxlib_urn_setup();
maxlib_velocity_setup();
maxlib_weibull_setup();
maxlib_wrap_setup();
post("\n maxlib :: Music Analysis eXtensions LIBrary");
post(" written by Olaf Matthes <olaf.matthes(a)gmx.de>");
post(" version "VERSION);
post(" compiled "__DATE__);
post(" latest version at http://www.akustische-kunst.org/puredata/maxlib/");
post(" objects: allow arbran arraycopy average beat beta bilex borax cauchy ");
post(" chord delta deny dist divide divmod edge expo fifo gauss ");
post(" gestalt history ignore iso lifo linear listfifo listfunnel ");
post(" match minus mlife multi nchange netclient netdist netrec ");
post(" netserver nroute pitch plus poisson pong pulse remote rewrap ");
post(" rhythm scale score speedlim split step subst sync temperature ");
post(" tilt timebang triang unroute urn velocity weibull wrap\n");
}
--- maxlib.pd_darwin DELETED ---
--- NEW FILE: install.bat ---
mkdir c:\pd\externs\maxlib
mkdir c:\pd\doc\5.reference\maxlib
cd help
copy *.pd c:\pd\doc\5.reference\maxlib
copy examplescore.txt c:\pd\doc\5.reference\maxlib
copy automata.txt c:\pd\externs\maxlib
cd ..
copy maxlib.dll c:\pd\externs\maxlib
copy README c:\pd\externs\maxlib
copy HISTORY c:\pd\externs\maxlib
copy LICENSE c:\pd\externs\maxlib
echo start Pd with flag "-lib c:\pd\externs\maxlib\maxlib"
--- NEW FILE: maxlib.dsp ---
# Microsoft Developer Studio Project File - Name="maxlib" - Package Owner=<4>
# Microsoft Developer Studio Generated Build File, Format Version 6.00
# ** DO NOT EDIT **
# TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102
CFG=maxlib - WIN32 RELEASE
!MESSAGE This is not a valid makefile. To build this project using NMAKE,
!MESSAGE use the Export Makefile command and run
!MESSAGE
!MESSAGE NMAKE /f "maxlib.mak".
!MESSAGE
!MESSAGE You can specify a configuration when running NMAKE
!MESSAGE by defining the macro CFG on the command line. For example:
!MESSAGE
!MESSAGE NMAKE /f "maxlib.mak" CFG="maxlib - WIN32 RELEASE"
!MESSAGE
!MESSAGE Possible choices for configuration are:
!MESSAGE
!MESSAGE "maxlib - Win32 Release" (based on "Win32 (x86) Dynamic-Link Library")
!MESSAGE "maxlib - Win32 Intel" (based on "Win32 (x86) Dynamic-Link Library")
!MESSAGE
# Begin Project
# PROP AllowPerConfigDependencies 1
# PROP Scc_ProjName ""
# PROP Scc_LocalPath ""
CPP=xicl6.exe
MTL=midl.exe
RSC=rc.exe
!IF "$(CFG)" == "maxlib - Win32 Release"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 0
# PROP BASE Output_Dir "Release"
# PROP BASE Intermediate_Dir "Release"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 0
# PROP Output_Dir ""
# PROP Intermediate_Dir "obj\"
# PROP Ignore_Export_Lib 0
# PROP Target_Dir ""
# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "maxlib_EXPORTS" /YX /FD /c
# ADD CPP /nologo /MT /W3 /GX /O2 /I "include" /D "WIN32" /D "NT" /D "_WINDOWS" /D "MAXLIB" /YX /FD /c
# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
# ADD MTL /nologo /win32
# SUBTRACT MTL /mktyplib203
# ADD BASE RSC /l 0xc07 /d "NDEBUG"
# ADD RSC /l 0xc07
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=xilink6.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /machine:I386
# ADD LINK32 kernel32.lib wsock32.lib user32.lib uuid.lib libc.lib oldnames.lib pthreadVC.lib c:\pd\bin\pd.lib /nologo /dll /machine:I386 /nodefaultlib /libpath:"../../bin" /export:maxlib_setup
# SUBTRACT LINK32 /pdb:none
!ELSEIF "$(CFG)" == "maxlib - Win32 Intel"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 0
# PROP BASE Output_Dir "maxlib___Win32_Intel"
# PROP BASE Intermediate_Dir "maxlib___Win32_Intel"
# PROP BASE Ignore_Export_Lib 0
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 0
# PROP Output_Dir ""
# PROP Intermediate_Dir ""
# PROP Ignore_Export_Lib 0
# PROP Target_Dir ""
# ADD BASE CPP /nologo /MT /W3 /GX /O2 /I "c:\pd\src" /D "WIN32" /D "NT" /D "_WINDOWS" /D "MAXLIB" /YX /FD /c
# ADD CPP /nologo /MT /W3 /I "include" /D "WIN32" /D "NT" /D "_WINDOWS" /D "IA32" /D "MAXLIB" /Fp"obj\maxlib.pch" /YX /Fo"obj\\" /FD /O3 /G7 /QaxW /c
# ADD BASE MTL /nologo /win32
# SUBTRACT BASE MTL /mktyplib203
# ADD MTL /nologo /win32
# SUBTRACT MTL /mktyplib203
# ADD BASE RSC /l 0xc07
# ADD RSC /l 0xc07
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=xilink6.exe
# ADD BASE LINK32 kernel32.lib wsock32.lib user32.lib uuid.lib libc.lib oldnames.lib pthreadVC.lib c:\pd\bin\pd.lib /nologo /dll /machine:I386 /nodefaultlib /libpath:"../../bin" /export:maxlib_setup
# SUBTRACT BASE LINK32 /pdb:none
# ADD LINK32 kernel32.lib wsock32.lib user32.lib uuid.lib libc.lib oldnames.lib pthreadVC.lib libm.lib libirc.lib svml_disp.lib c:\pd\bin\pd.lib /nologo /dll /machine:I386 /nodefaultlib /libpath:"../../bin" /export:maxlib_setup
# SUBTRACT LINK32 /pdb:none
!ENDIF
# Begin Target
# Name "maxlib - Win32 Release"
# Name "maxlib - Win32 Intel"
# Begin Group "Quellcodedateien"
# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
# Begin Source File
SOURCE=.\src\arbran.c
# End Source File
# Begin Source File
SOURCE=.\src\average.c
# End Source File
# Begin Source File
SOURCE=.\src\beat.c
# End Source File
# Begin Source File
SOURCE=.\src\beta.c
# End Source File
# Begin Source File
SOURCE=.\src\bilex.c
# End Source File
# Begin Source File
SOURCE=.\src\borax.c
# End Source File
# Begin Source File
SOURCE=.\src\cauchy.c
# End Source File
# Begin Source File
SOURCE=.\src\chord.c
# End Source File
# Begin Source File
SOURCE=.\src\delta.c
# End Source File
# Begin Source File
SOURCE=.\src\dist.c
# End Source File
# Begin Source File
SOURCE=.\src\divide.c
# End Source File
# Begin Source File
SOURCE=.\src\divmod.c
# End Source File
# Begin Source File
SOURCE=.\src\edge.c
# End Source File
# Begin Source File
SOURCE=.\src\expo.c
# End Source File
# Begin Source File
SOURCE=.\src\fifo.c
# End Source File
# Begin Source File
SOURCE=.\src\gauss.c
# End Source File
# Begin Source File
SOURCE=.\src\gestalt.c
# End Source File
# Begin Source File
SOURCE=.\src\history.c
# End Source File
# Begin Source File
SOURCE=.\src\ignore.c
# End Source File
# Begin Source File
SOURCE=.\src\iso.c
# End Source File
# Begin Source File
SOURCE=.\src\lifo.c
# End Source File
# Begin Source File
SOURCE=.\src\limit.c
# End Source File
# Begin Source File
SOURCE=.\src\linear.c
# End Source File
# Begin Source File
SOURCE=.\src\listfunnel.c
# End Source File
# Begin Source File
SOURCE=.\src\match.c
# End Source File
# Begin Source File
SOURCE=.\maxlib.c
# End Source File
# Begin Source File
SOURCE=.\src\minus.c
# End Source File
# Begin Source File
SOURCE=.\src\mlife.c
# End Source File
# Begin Source File
SOURCE=.\src\multi.c
# End Source File
# Begin Source File
SOURCE=.\src\netclient.c
# End Source File
# Begin Source File
SOURCE=.\src\netdist.c
# End Source File
# Begin Source File
SOURCE=.\src\netrec.c
# End Source File
# Begin Source File
SOURCE=.\src\netserver.c
# End Source File
# Begin Source File
SOURCE=.\src\nroute.c
# End Source File
# Begin Source File
SOURCE=.\src\pitch.c
# End Source File
# Begin Source File
SOURCE=.\src\plus.c
# End Source File
# Begin Source File
SOURCE=.\src\poisson.c
# End Source File
# Begin Source File
SOURCE=.\src\pong.c
# End Source File
# Begin Source File
SOURCE=.\src\pulse.c
# End Source File
# Begin Source File
SOURCE=.\src\remote.c
# End Source File
# Begin Source File
SOURCE=.\src\rhythm.c
# End Source File
# Begin Source File
SOURCE=.\src\scale.c
# End Source File
# Begin Source File
SOURCE=.\src\score.c
# End Source File
# Begin Source File
SOURCE=.\src\speedlim.c
# End Source File
# Begin Source File
SOURCE=.\src\step.c
# End Source File
# Begin Source File
SOURCE=.\src\subst.c
# End Source File
# Begin Source File
SOURCE=.\src\temperature.c
# End Source File
# Begin Source File
SOURCE=.\src\tilt.c
# End Source File
# Begin Source File
SOURCE=.\src\triang.c
# End Source File
# Begin Source File
SOURCE=.\src\velocity.c
# End Source File
# Begin Source File
SOURCE=.\src\weibull.c
# End Source File
# End Group
# Begin Group "Header-Dateien"
# PROP Default_Filter "h;hpp;hxx;hm;inl"
# Begin Source File
SOURCE=.\include\m_imp.h
# End Source File
# Begin Source File
SOURCE=.\include\m_pd.h
# End Source File
# End Group
# End Target
# End Project
--- NEW FILE: README ---
maxlib - music analysis extensions library, version 1.5.2
copyright (c) 2002-2003 by Olaf Matthes
maxlib is a library of non-tilde externals for pd (by Miller Puckette).
The objects can be very useful to analyse any musical performance. Some
of the objects are 'borrowed' from Max (they are not ported but
rewritten for Pd - cheap immitations).
maxib has recently been extended by objects of more general use and some
which can be use for composition purposes.
To compile maxlib on win32 (using VC++ 6.0) just type "nmake pd_nt" or use
the MS VC++ project provided. On Linux simply do "make pd_linux" and "make
install".
You have to modify the makefile to make it point to your m_ph.h !!!
To use maxlib place the file maxlib.dll for win32 or maxlib.pd_linux
in a directory of your choise and start pd with '-lib path/to/maxlib' flag.
On windows you can run install.bat to copy all files to the apropiate places.
This assumes that you have pd installed in c:\pd\ ! The maxlib directory will
then be c:\pd\externs\maxlib\
This software is published under GPL terms, see file LICENSE.
This is software with ABSOLUTELY NO WARRANTY.
Use it at your OWN RISK. It's possible to damage e.g. hardware or your hearing
due to a bug or for other reasons.
*****************************************************************************
included objects: see http://www.akustische-kunst.org/puredata/maxlib/
Latest version can be found at:
http://www.akustische-kunst.org/puredata/maxlib/
Please report any bugs to olaf.matthes(a)gmx.de!
--- NEW FILE: LICENSE ---
GNU GENERAL PUBLIC LICENSE
Version 2, June 1991
Copyright (C) 1989, 1991 Free Software Foundation, Inc.
59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The licenses for most software are designed to take away your
freedom to share and change it. By contrast, the GNU General Public
License is intended to guarantee your freedom to share and change free
software--to make sure the software is free for all its users. This
General Public License applies to most of the Free Software
Foundation's software and to any other program whose authors commit to
using it. (Some other Free Software Foundation software is covered by
the GNU Library General Public License instead.) You can apply it to
your programs, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
this service if you wish), that you receive source code or can get it
if you want it, that you can change the software or use pieces of it
in new free programs; and that you know you can do these things.
To protect your rights, we need to make restrictions that forbid
anyone to deny you these rights or to ask you to surrender the rights.
These restrictions translate to certain responsibilities for you if you
distribute copies of the software, or if you modify it.
For example, if you distribute copies of such a program, whether
gratis or for a fee, you must give the recipients all the rights that
you have. You must make sure that they, too, receive or can get the
source code. And you must show them these terms so they know their
rights.
We protect your rights with two steps: (1) copyright the software, and
(2) offer you this license which gives you legal permission to copy,
distribute and/or modify the software.
Also, for each author's protection and ours, we want to make certain
that everyone understands that there is no warranty for this free
software. If the software is modified by someone else and passed on, we
want its recipients to know that what they have is not the original, so
that any problems introduced by others will not reflect on the original
authors' reputations.
Finally, any free program is threatened constantly by software
patents. We wish to avoid the danger that redistributors of a free
program will individually obtain patent licenses, in effect making the
program proprietary. To prevent this, we have made it clear that any
patent must be licensed for everyone's free use or not licensed at all.
The precise terms and conditions for copying, distribution and
modification follow.
GNU GENERAL PUBLIC LICENSE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
0. This License applies to any program or other work which contains
a notice placed by the copyright holder saying it may be distributed
under the terms of this General Public License. The "Program", below,
refers to any such program or work, and a "work based on the Program"
means either the Program or any derivative work under copyright law:
that is to say, a work containing the Program or a portion of it,
either verbatim or with modifications and/or translated into another
language. (Hereinafter, translation is included without limitation in
the term "modification".) Each licensee is addressed as "you".
Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope. The act of
running the Program is not restricted, and the output from the Program
is covered only if its contents constitute a work based on the
Program (independent of having been made by running the Program).
Whether that is true depends on what the Program does.
1. You may copy and distribute verbatim copies of the Program's
source code as you receive it, in any medium, provided that you
conspicuously and appropriately publish on each copy an appropriate
copyright notice and disclaimer of warranty; keep intact all the
notices that refer to this License and to the absence of any warranty;
and give any other recipients of the Program a copy of this License
along with the Program.
You may charge a fee for the physical act of transferring a copy, and
you may at your option offer warranty protection in exchange for a fee.
2. You may modify your copy or copies of the Program or any portion
of it, thus forming a work based on the Program, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:
a) You must cause the modified files to carry prominent notices
stating that you changed the files and the date of any change.
b) You must cause any work that you distribute or publish, that in
whole or in part contains or is derived from the Program or any
part thereof, to be licensed as a whole at no charge to all third
parties under the terms of this License.
c) If the modified program normally reads commands interactively
when run, you must cause it, when started running for such
interactive use in the most ordinary way, to print or display an
announcement including an appropriate copyright notice and a
notice that there is no warranty (or else, saying that you provide
a warranty) and that users may redistribute the program under
these conditions, and telling the user how to view a copy of this
License. (Exception: if the Program itself is interactive but
does not normally print such an announcement, your work based on
the Program is not required to print an announcement.)
These requirements apply to the modified work as a whole. If
identifiable sections of that work are not derived from the Program,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works. But when you
distribute the same sections as part of a whole which is a work based
on the Program, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote it.
Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Program.
In addition, mere aggregation of another work not based on the Program
with the Program (or with a work based on the Program) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.
3. You may copy and distribute the Program (or a work based on it,
under Section 2) in object code or executable form under the terms of
Sections 1 and 2 above provided that you also do one of the following:
a) Accompany it with the complete corresponding machine-readable
source code, which must be distributed under the terms of Sections
1 and 2 above on a medium customarily used for software interchange; or,
b) Accompany it with a written offer, valid for at least three
years, to give any third party, for a charge no more than your
cost of physically performing source distribution, a complete
machine-readable copy of the corresponding source code, to be
distributed under the terms of Sections 1 and 2 above on a medium
customarily used for software interchange; or,
c) Accompany it with the information you received as to the offer
to distribute corresponding source code. (This alternative is
allowed only for noncommercial distribution and only if you
received the program in object code or executable form with such
an offer, in accord with Subsection b above.)
The source code for a work means the preferred form of the work for
making modifications to it. For an executable work, complete source
code means all the source code for all modules it contains, plus any
associated interface definition files, plus the scripts used to
control compilation and installation of the executable. However, as a
special exception, the source code distributed need not include
anything that is normally distributed (in either source or binary
form) with the major components (compiler, kernel, and so on) of the
operating system on which the executable runs, unless that component
itself accompanies the executable.
If distribution of executable or object code is made by offering
access to copy from a designated place, then offering equivalent
access to copy the source code from the same place counts as
distribution of the source code, even though third parties are not
compelled to copy the source along with the object code.
4. You may not copy, modify, sublicense, or distribute the Program
except as expressly provided under this License. Any attempt
otherwise to copy, modify, sublicense or distribute the Program is
void, and will automatically terminate your rights under this License.
However, parties who have received copies, or rights, from you under
this License will not have their licenses terminated so long as such
parties remain in full compliance.
5. You are not required to accept this License, since you have not
signed it. However, nothing else grants you permission to modify or
distribute the Program or its derivative works. These actions are
prohibited by law if you do not accept this License. Therefore, by
modifying or distributing the Program (or any work based on the
Program), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Program or works based on it.
6. Each time you redistribute the Program (or any work based on the
Program), the recipient automatically receives a license from the
original licensor to copy, distribute or modify the Program subject to
these terms and conditions. You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties to
this License.
7. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Program at all. For example, if a patent
license would not permit royalty-free redistribution of the Program by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Program.
If any portion of this section is held invalid or unenforceable under
any particular circumstance, the balance of the section is intended to
apply and the section as a whole is intended to apply in other
circumstances.
It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system, which is
implemented by public license practices. Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.
This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.
8. If the distribution and/or use of the Program is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Program under this License
may add an explicit geographical distribution limitation excluding
those countries, so that distribution is permitted only in or among
countries not thus excluded. In such case, this License incorporates
the limitation as if written in the body of this License.
9. The Free Software Foundation may publish revised and/or new versions
of the General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.
Each version is given a distinguishing version number. If the Program
specifies a version number of this License which applies to it and "any
later version", you have the option of following the terms and conditions
either of that version or of any later version published by the Free
Software Foundation. If the Program does not specify a version number of
this License, you may choose any version ever published by the Free Software
Foundation.
10. If you wish to incorporate parts of the Program into other free
programs whose distribution conditions are different, write to the author
to ask for permission. For software which is copyrighted by the Free
Software Foundation, write to the Free Software Foundation; we sometimes
make exceptions for this. Our decision will be guided by the two goals
of preserving the free status of all derivatives of our free software and
of promoting the sharing and reuse of software generally.
NO WARRANTY
11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
REPAIR OR CORRECTION.
12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
POSSIBILITY OF SUCH DAMAGES.
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Programs
If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.
To do so, attach the following notices to the program. It is safest
to attach them to the start of each source file to most effectively
convey the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.
<one line to give the program's name and a brief idea of what it does.>
Copyright (C) 19yy <name of author>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Also add information on how to contact you by electronic and paper mail.
If the program is interactive, make it output a short notice like this
when it starts in an interactive mode:
Gnomovision version 69, Copyright (C) 19yy name of author
Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.
The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License. Of course, the commands you use may
be called something other than `show w' and `show c'; they could even be
mouse-clicks or menu items--whatever suits your program.
You should also get your employer (if you work as a programmer) or your
school, if any, to sign a "copyright disclaimer" for the program, if
necessary. Here is a sample; alter the names:
Yoyodyne, Inc., hereby disclaims all copyright interest in the program
`Gnomovision' (which makes passes at compilers) written by James Hacker.
<signature of Ty Coon>, 1 April 1989
Ty Coon, President of Vice
This General Public License does not permit incorporating your program into
proprietary programs. If your program is a subroutine library, you may
consider it more useful to permit linking proprietary applications with the
library. If this is what you want to do, use the GNU Library General
Public License instead of this License.
--- NEW FILE: makefile ---
NAME=maxlib
CSYM=maxlib
current: pd_irix6
# ----------------------- NT -----------------------
pd_nt: $(NAME).dll
.SUFFIXES: .dll
# define PD_0_36 to compilie with pd0.36 and below
PDNTCFLAGS = /W3 /WX /MD /O2 /G6 /DNT /DPD /DPD_0_36 /DMAXLIB /nologo
VC="C:\Programme\Microsoft Visual Studio\VC98"
PDNTINCLUDE = /I. /Ic:\pd\tcl\include /Ic:\pd\src /I$(VC)\include /Iinclude
PDNTLDIR = $(VC)\Lib
PDNTLIB = $(PDNTLDIR)\msvcrt.lib \
$(PDNTLDIR)\oldnames.lib \
$(PDNTLDIR)\kernel32.lib \
$(PDNTLDIR)\user32.lib \
$(PDNTLDIR)\uuid.lib \
$(PDNTLDIR)\ws2_32.lib \
$(PDNTLDIR)\pthreadVC.lib \
c:\pd\bin\pd.lib
PDNTEXTERNALS = borax.obj divide.obj ignore.obj match.obj pitch.obj speedlim.obj \
minus.obj plus.obj multi.obj average.obj chord.obj score.obj \
divmod.obj pulse.obj fifo.obj lifo.obj iso.obj dist.obj \
step.obj netdist.obj beat.obj rhythm.obj history.obj netrec.obj \
scale.obj delta.obj velocity.obj listfunnel.obj tilt.obj \
gestalt.obj temperature.obj arbran.obj beta.obj bilex.obj \
cauchy.obj expo.obj gauss.obj linear.obj poisson.obj triang.obj \
weibull.obj netserver.obj netclient.obj nroute.obj remote.obj \
edge.obj subst.obj pong.obj mlife.obj limit.obj unroute.obj \
urn.obj split.obj wrap.obj rewrap.obj timebang.obj sync.obj \
listfifo.obj arraycopy.obj allow.obj deny.obj nchange.obj
.c.dll:
cl $(PDNTCFLAGS) $(PDNTINCLUDE) /c src\allow.c
cl $(PDNTCFLAGS) $(PDNTINCLUDE) /c src\arbran.c
cl $(PDNTCFLAGS) $(PDNTINCLUDE) /c src\arraycopy.c
cl $(PDNTCFLAGS) $(PDNTINCLUDE) /c src\average.c
cl $(PDNTCFLAGS) $(PDNTINCLUDE) /c src\beat.c
cl $(PDNTCFLAGS) $(PDNTINCLUDE) /c src\beta.c
cl $(PDNTCFLAGS) $(PDNTINCLUDE) /c src\bilex.c
cl $(PDNTCFLAGS) $(PDNTINCLUDE) /c src\borax.c
cl $(PDNTCFLAGS) $(PDNTINCLUDE) /c src\cauchy.c
cl $(PDNTCFLAGS) $(PDNTINCLUDE) /c src\chord.c
cl $(PDNTCFLAGS) $(PDNTINCLUDE) /c src\delta.c
cl $(PDNTCFLAGS) $(PDNTINCLUDE) /c src\deny.c
cl $(PDNTCFLAGS) $(PDNTINCLUDE) /c src\dist.c
cl $(PDNTCFLAGS) $(PDNTINCLUDE) /c src\divide.c
cl $(PDNTCFLAGS) $(PDNTINCLUDE) /c src\divmod.c
cl $(PDNTCFLAGS) $(PDNTINCLUDE) /c src\edge.c
cl $(PDNTCFLAGS) $(PDNTINCLUDE) /c src\expo.c
cl $(PDNTCFLAGS) $(PDNTINCLUDE) /c src\fifo.c
cl $(PDNTCFLAGS) $(PDNTINCLUDE) /c src\gauss.c
cl $(PDNTCFLAGS) $(PDNTINCLUDE) /c src\gestalt.c
cl $(PDNTCFLAGS) $(PDNTINCLUDE) /c src\history.c
cl $(PDNTCFLAGS) $(PDNTINCLUDE) /c src\ignore.c
cl $(PDNTCFLAGS) $(PDNTINCLUDE) /c src\iso.c
cl $(PDNTCFLAGS) $(PDNTINCLUDE) /c src\linear.c
cl $(PDNTCFLAGS) $(PDNTINCLUDE) /c src\listfifo.c
cl $(PDNTCFLAGS) $(PDNTINCLUDE) /c src\listfunnel.c
cl $(PDNTCFLAGS) $(PDNTINCLUDE) /c src\lifo.c
cl $(PDNTCFLAGS) $(PDNTINCLUDE) /c src\limit.c
cl $(PDNTCFLAGS) $(PDNTINCLUDE) /c src\match.c
cl $(PDNTCFLAGS) $(PDNTINCLUDE) /c src\minus.c
cl $(PDNTCFLAGS) $(PDNTINCLUDE) /c src\mlife.c
cl $(PDNTCFLAGS) $(PDNTINCLUDE) /c src\multi.c
cl $(PDNTCFLAGS) $(PDNTINCLUDE) /c src\nchange.c
cl $(PDNTCFLAGS) $(PDNTINCLUDE) /c src\netclient.c
cl $(PDNTCFLAGS) $(PDNTINCLUDE) /c src\netdist.c
cl $(PDNTCFLAGS) $(PDNTINCLUDE) /c src\netrec.c
cl $(PDNTCFLAGS) $(PDNTINCLUDE) /c src\netserver.c
cl $(PDNTCFLAGS) $(PDNTINCLUDE) /c src\nroute.c
cl $(PDNTCFLAGS) $(PDNTINCLUDE) /c src\pitch.c
cl $(PDNTCFLAGS) $(PDNTINCLUDE) /c src\plus.c
cl $(PDNTCFLAGS) $(PDNTINCLUDE) /c src\poisson.c
cl $(PDNTCFLAGS) $(PDNTINCLUDE) /c src\pong.c
cl $(PDNTCFLAGS) $(PDNTINCLUDE) /c src\pulse.c
cl $(PDNTCFLAGS) $(PDNTINCLUDE) /c src\remote.c
cl $(PDNTCFLAGS) $(PDNTINCLUDE) /c src\rewrap.c
cl $(PDNTCFLAGS) $(PDNTINCLUDE) /c src\rhythm.c
cl $(PDNTCFLAGS) $(PDNTINCLUDE) /c src\scale.c
cl $(PDNTCFLAGS) $(PDNTINCLUDE) /c src\score.c
cl $(PDNTCFLAGS) $(PDNTINCLUDE) /c src\speedlim.c
cl $(PDNTCFLAGS) $(PDNTINCLUDE) /c src\split.c
cl $(PDNTCFLAGS) $(PDNTINCLUDE) /c src\step.c
cl $(PDNTCFLAGS) $(PDNTINCLUDE) /c src\subst.c
cl $(PDNTCFLAGS) $(PDNTINCLUDE) /c src\sync.c
cl $(PDNTCFLAGS) $(PDNTINCLUDE) /c src\temperature.c
cl $(PDNTCFLAGS) $(PDNTINCLUDE) /c src\tilt.c
cl $(PDNTCFLAGS) $(PDNTINCLUDE) /c src\timebang.c
cl $(PDNTCFLAGS) $(PDNTINCLUDE) /c src\triang.c
cl $(PDNTCFLAGS) $(PDNTINCLUDE) /c src\unroute.c
cl $(PDNTCFLAGS) $(PDNTINCLUDE) /c src\urn.c
cl $(PDNTCFLAGS) $(PDNTINCLUDE) /c src\velocity.c
cl $(PDNTCFLAGS) $(PDNTINCLUDE) /c src\weibull.c
cl $(PDNTCFLAGS) $(PDNTINCLUDE) /c src\wrap.c
cl $(PDNTCFLAGS) $(PDNTINCLUDE) /c $*.c
link /dll /export:$(CSYM)_setup $*.obj $(PDNTEXTERNALS) $(PDNTLIB)
# ----------------------- IRIX 6.5 -----------------------
pd_irix6: $(NAME).pd_irix6
.SUFFIXES: .pd_irix6
SGICFLAGS6 = -n32 -DPD -DUNIX -DIRIX -DN32 -woff 1080,1064,1185 \
-OPT:roundoff=3 -OPT:IEEE_arithmetic=3 -OPT:cray_ivdep=true \
-Ofast=ip32 -r12000 -shared
SGIINCLUDE = -I../../src
SGIGCFLAGS = -mabi=n32 -DPD -DMAXLIB -DUNIX -DIRIX -DN32 -O3 -funroll-loops -fomit-frame-pointer \
-Wall -W -Wshadow -Wstrict-prototypes \
-Wno-unused -Wno-parentheses -Wno-switch -mips4
SGIEXTERNALS = borax.o ignore.o match.o pitch.o speedlim.o \
plus.o minus.o divide.o multi.o average.o chord.o \
score.o divmod.o pulse.o fifo.o lifo.o iso.o dist.o \
remote.o step.o netdist.o beat.o rhythm.o history.o \
netrec.o scale.o delta.o velocity.o mlife.o subst.o \
listfunnel.o tilt.o gestalt.o temperature.o arbran.o \
beta.o bilex.o cauchy.o expo.o gauss.o linear.o poisson.o \
triang.o weibull.o netserver.o netclient.o nroute.o \
edge.o pong.o limit.o unroute.o urn.o split.o wrap.o \
rewrap.o timebang.o sync.o listfifo.o arraycopy.o \
allow.o deny.o nchange.o
.c.pd_irix6:
gcc $(SGIGCFLAGS) $(SGIINCLUDE) -c src/allow.c
gcc $(SGIGCFLAGS) $(SGIINCLUDE) -c src/arbran.c
gcc $(SGIGCFLAGS) $(SGIINCLUDE) -c src/arraycopy.c
gcc $(SGIGCFLAGS) $(SGIINCLUDE) -c src/average.c
gcc $(SGIGCFLAGS) $(SGIINCLUDE) -c src/beat.c
gcc $(SGIGCFLAGS) $(SGIINCLUDE) -c src/beta.c
gcc $(SGIGCFLAGS) $(SGIINCLUDE) -c src/bilex.c
gcc $(SGIGCFLAGS) $(SGIINCLUDE) -c src/borax.c
gcc $(SGIGCFLAGS) $(SGIINCLUDE) -c src/cauchy.c
gcc $(SGIGCFLAGS) $(SGIINCLUDE) -c src/chord.c
gcc $(SGIGCFLAGS) $(SGIINCLUDE) -c src/delta.c
gcc $(SGIGCFLAGS) $(SGIINCLUDE) -c src/deny.c
gcc $(SGIGCFLAGS) $(SGIINCLUDE) -c src/dist.c
gcc $(SGIGCFLAGS) $(SGIINCLUDE) -c src/divide.c
gcc $(SGIGCFLAGS) $(SGIINCLUDE) -c src/divmod.c
gcc $(SGIGCFLAGS) $(SGIINCLUDE) -c src/edge.c
gcc $(SGIGCFLAGS) $(SGIINCLUDE) -c src/expo.c
gcc $(SGIGCFLAGS) $(SGIINCLUDE) -c src/fifo.c
gcc $(SGIGCFLAGS) $(SGIINCLUDE) -c src/gauss.c
gcc $(SGIGCFLAGS) $(SGIINCLUDE) -c src/gestalt.c
gcc $(SGIGCFLAGS) $(SGIINCLUDE) -c src/history.c
gcc $(SGIGCFLAGS) $(SGIINCLUDE) -c src/ignore.c
gcc $(SGIGCFLAGS) $(SGIINCLUDE) -c src/iso.c
gcc $(SGIGCFLAGS) $(SGIINCLUDE) -c src/lifo.c
gcc $(SGIGCFLAGS) $(SGIINCLUDE) -c src/limit.c
gcc $(SGIGCFLAGS) $(SGIINCLUDE) -c src/linear.c
gcc $(SGIGCFLAGS) $(SGIINCLUDE) -c src/listfifo.c
gcc $(SGIGCFLAGS) $(SGIINCLUDE) -c src/listfunnel.c
gcc $(SGIGCFLAGS) $(SGIINCLUDE) -c src/match.c
gcc $(SGIGCFLAGS) $(SGIINCLUDE) -c src/minus.c
gcc $(SGIGCFLAGS) $(SGIINCLUDE) -c src/mlife.c
gcc $(SGIGCFLAGS) $(SGIINCLUDE) -c src/multi.c
gcc $(SGIGCFLAGS) $(SGIINCLUDE) -c src/nchange.c
gcc $(SGIGCFLAGS) $(SGIINCLUDE) -c src/netclient.c
gcc $(SGIGCFLAGS) $(SGIINCLUDE) -c src/netdist.c
gcc $(SGIGCFLAGS) $(SGIINCLUDE) -c src/netrec.c
gcc $(SGIGCFLAGS) $(SGIINCLUDE) -c src/netserver.c
gcc $(SGIGCFLAGS) $(SGIINCLUDE) -c src/nroute.c
gcc $(SGIGCFLAGS) $(SGIINCLUDE) -c src/plus.c
gcc $(SGIGCFLAGS) $(SGIINCLUDE) -c src/pong.c
gcc $(SGIGCFLAGS) $(SGIINCLUDE) -c src/poisson.c
gcc $(SGIGCFLAGS) $(SGIINCLUDE) -c src/pulse.c
gcc $(SGIGCFLAGS) $(SGIINCLUDE) -c src/pitch.c
gcc $(SGIGCFLAGS) $(SGIINCLUDE) -c src/remote.c
gcc $(SGIGCFLAGS) $(SGIINCLUDE) -c src/rewrap.c
gcc $(SGIGCFLAGS) $(SGIINCLUDE) -c src/rhythm.c
gcc $(SGIGCFLAGS) $(SGIINCLUDE) -c src/scale.c
gcc $(SGIGCFLAGS) $(SGIINCLUDE) -c src/score.c
gcc $(SGIGCFLAGS) $(SGIINCLUDE) -c src/speedlim.c
gcc $(SGIGCFLAGS) $(SGIINCLUDE) -c src/split.c
gcc $(SGIGCFLAGS) $(SGIINCLUDE) -c src/step.c
gcc $(SGIGCFLAGS) $(SGIINCLUDE) -c src/subst.c
gcc $(SGIGCFLAGS) $(SGIINCLUDE) -c src/sync.c
gcc $(SGIGCFLAGS) $(SGIINCLUDE) -c src/temperature.c
gcc $(SGIGCFLAGS) $(SGIINCLUDE) -c src/tilt.c
gcc $(SGIGCFLAGS) $(SGIINCLUDE) -c src/timebang.c
gcc $(SGIGCFLAGS) $(SGIINCLUDE) -c src/triang.c
gcc $(SGIGCFLAGS) $(SGIINCLUDE) -c src/unroute.c
gcc $(SGIGCFLAGS) $(SGIINCLUDE) -c src/urn.c
gcc $(SGIGCFLAGS) $(SGIINCLUDE) -c src/velocity.c
gcc $(SGIGCFLAGS) $(SGIINCLUDE) -c src/weibull.c
gcc $(SGIGCFLAGS) $(SGIINCLUDE) -c src/wrap.c
gcc $(SGIGCFLAGS) $(SGIINCLUDE) -c $*.c
ld -n32 -IPA -shared -rdata_shared -o $*.pd_irix6 $*.o $(SGIEXTERNALS)
rm $*.o
# ----------------------- Mac OS X (Darwin) -----------------------
pd_darwin: $(NAME).pd_darwin
.SUFFIXES: .pd_darwin
DARWINCFLAGS = -DPD -DMAXLIB -DUNIX -DMACOSX -O2 \
-Wall -W -Wshadow -Wstrict-prototypes \
-Wno-unused -Wno-parentheses -Wno-switch
# where is your m_pd.h ???
DARWININCLUDE = -I../../src -I../../obj
DARWINEXTERNALS = borax.o ignore.o match.o pitch.o speedlim.o \
plus.o minus.o divide.o multi.o average.o chord.o \
score.o divmod.o pulse.o fifo.o lifo.o iso.o dist.o \
remote.o step.o netdist.o beat.o rhythm.o history.o \
netrec.o scale.o delta.o velocity.o mlife.o subst.o \
listfunnel.o tilt.o gestalt.o temperature.o arbran.o \
beta.o bilex.o cauchy.o expo.o gauss.o linear.o poisson.o \
triang.o weibull.o netserver.o netclient.o nroute.o \
edge.o pong.o limit.o unroute.o urn.o split.o wrap.o \
rewrap.o timebang.o sync.o listfifo.o arraycopy.o \
allow.o deny.o nchange.o
.c.pd_darwin:
cc $(DARWINCFLAGS) $(DARWININCLUDE) -c src/allow.c
cc $(DARWINCFLAGS) $(DARWININCLUDE) -c src/arbran.c
cc $(DARWINCFLAGS) $(DARWININCLUDE) -c src/arraycopy.c
cc $(DARWINCFLAGS) $(DARWININCLUDE) -c src/average.c
cc $(DARWINCFLAGS) $(DARWININCLUDE) -c src/beat.c
cc $(DARWINCFLAGS) $(DARWININCLUDE) -c src/beta.c
cc $(DARWINCFLAGS) $(DARWININCLUDE) -c src/bilex.c
cc $(DARWINCFLAGS) $(DARWININCLUDE) -c src/borax.c
cc $(DARWINCFLAGS) $(DARWININCLUDE) -c src/cauchy.c
cc $(DARWINCFLAGS) $(DARWININCLUDE) -c src/chord.c
cc $(DARWINCFLAGS) $(DARWININCLUDE) -c src/delta.c
cc $(DARWINCFLAGS) $(DARWININCLUDE) -c src/deny.c
cc $(DARWINCFLAGS) $(DARWININCLUDE) -c src/dist.c
cc $(DARWINCFLAGS) $(DARWININCLUDE) -c src/divide.c
cc $(DARWINCFLAGS) $(DARWININCLUDE) -c src/divmod.c
cc $(DARWINCFLAGS) $(DARWININCLUDE) -c src/edge.c
cc $(DARWINCFLAGS) $(DARWININCLUDE) -c src/expo.c
cc $(DARWINCFLAGS) $(DARWININCLUDE) -c src/fifo.c
cc $(DARWINCFLAGS) $(DARWININCLUDE) -c src/gauss.c
cc $(DARWINCFLAGS) $(DARWININCLUDE) -c src/gestalt.c
cc $(DARWINCFLAGS) $(DARWININCLUDE) -c src/history.c
cc $(DARWINCFLAGS) $(DARWININCLUDE) -c src/ignore.c
cc $(DARWINCFLAGS) $(DARWININCLUDE) -c src/iso.c
cc $(DARWINCFLAGS) $(DARWININCLUDE) -c src/lifo.c
cc $(DARWINCFLAGS) $(DARWININCLUDE) -c src/limit.c
cc $(DARWINCFLAGS) $(DARWININCLUDE) -c src/linear.c
cc $(DARWINCFLAGS) $(DARWININCLUDE) -c src/listfifo.c
cc $(DARWINCFLAGS) $(DARWININCLUDE) -c src/listfunnel.c
cc $(DARWINCFLAGS) $(DARWININCLUDE) -c src/match.c
cc $(DARWINCFLAGS) $(DARWININCLUDE) -c src/minus.c
cc $(DARWINCFLAGS) $(DARWININCLUDE) -c src/mlife.c
cc $(DARWINCFLAGS) $(DARWININCLUDE) -c src/multi.c
cc $(DARWINCFLAGS) $(DARWININCLUDE) -c src/nchange.c
cc $(DARWINCFLAGS) $(DARWININCLUDE) -c src/netclient.c
cc $(DARWINCFLAGS) $(DARWININCLUDE) -c src/netdist.c
cc $(DARWINCFLAGS) $(DARWININCLUDE) -c src/netrec.c
cc $(DARWINCFLAGS) $(DARWININCLUDE) -c src/netserver.c
cc $(DARWINCFLAGS) $(DARWININCLUDE) -c src/nroute.c
cc $(DARWINCFLAGS) $(DARWININCLUDE) -c src/plus.c
cc $(DARWINCFLAGS) $(DARWININCLUDE) -c src/poisson.c
cc $(DARWINCFLAGS) $(DARWININCLUDE) -c src/pong.c
cc $(DARWINCFLAGS) $(DARWININCLUDE) -c src/pulse.c
cc $(DARWINCFLAGS) $(DARWININCLUDE) -c src/pitch.c
cc $(DARWINCFLAGS) $(DARWININCLUDE) -c src/remote.c
cc $(DARWINCFLAGS) $(DARWININCLUDE) -c src/rewrap.c
cc $(DARWINCFLAGS) $(DARWININCLUDE) -c src/rhythm.c
cc $(DARWINCFLAGS) $(DARWININCLUDE) -c src/scale.c
cc $(DARWINCFLAGS) $(DARWININCLUDE) -c src/score.c
cc $(DARWINCFLAGS) $(DARWININCLUDE) -c src/speedlim.c
cc $(DARWINCFLAGS) $(DARWININCLUDE) -c src/weibull.c
cc $(DARWINCFLAGS) $(DARWININCLUDE) -c src/split.c
cc $(DARWINCFLAGS) $(DARWININCLUDE) -c src/step.c
cc $(DARWINCFLAGS) $(DARWININCLUDE) -c src/subst.c
cc $(DARWINCFLAGS) $(DARWININCLUDE) -c src/sync.c
cc $(DARWINCFLAGS) $(DARWININCLUDE) -c src/temperature.c
cc $(DARWINCFLAGS) $(DARWININCLUDE) -c src/tilt.c
cc $(DARWINCFLAGS) $(DARWININCLUDE) -c src/timebang.c
cc $(DARWINCFLAGS) $(DARWININCLUDE) -c src/triang.c
cc $(DARWINCFLAGS) $(DARWININCLUDE) -c src/unroute.c
cc $(DARWINCFLAGS) $(DARWININCLUDE) -c src/urn.c
cc $(DARWINCFLAGS) $(DARWININCLUDE) -c src/velocity.c
cc $(DARWINCFLAGS) $(DARWININCLUDE) -c src/weibull.c
cc $(DARWINCFLAGS) $(DARWININCLUDE) -c src/wrap.c
cc $(DARWINCFLAGS) $(DARWININCLUDE) -c $*.c
cc -bundle -undefined suppress -flat_namespace -o $*.pd_darwin $*.o $(DARWINEXTERNALS)
rm -f $*.o ../$*.pd_darwin
ln -s $*/$*.pd_darwin ..
# ----------------------- LINUX i386 -----------------------
pd_linux: $(NAME).pd_linux
.SUFFIXES: .pd_linux
LINUXCFLAGS = -DPD -DMAXLIB -DUNIX -O2 -funroll-loops -fomit-frame-pointer \
-Wall -W -Wshadow \
-Wno-unused -Wno-parentheses -Wno-switch
# where is your m_pd.h ???
LINUXINCLUDE = -I/usr/local/include -I./include
LINUXEXTERNALS = borax.o ignore.o match.o pitch.o speedlim.o \
plus.o minus.o divide.o multi.o average.o chord.o \
score.o divmod.o pulse.o fifo.o lifo.o iso.o dist.o \
remote.o step.o netdist.o beat.o rhythm.o history.o \
netrec.o scale.o delta.o velocity.o mlife.o subst.o \
listfunnel.o tilt.o gestalt.o temperature.o arbran.o \
beta.o bilex.o cauchy.o expo.o gauss.o linear.o poisson.o \
triang.o weibull.o netserver.o netclient.o nroute.o \
edge.o pong.o limit.o unroute.o urn.o split.o wrap.o \
rewrap.o timebang.o sync.o listfifo.o arraycopy.o \
allow.o deny.o nchange.o
.c.pd_linux:
cc $(LINUXCFLAGS) $(LINUXINCLUDE) -c src/allow.c
cc $(LINUXCFLAGS) $(LINUXINCLUDE) -c src/arbran.c
cc $(LINUXCFLAGS) $(LINUXINCLUDE) -c src/arraycopy.c
cc $(LINUXCFLAGS) $(LINUXINCLUDE) -c src/average.c
cc $(LINUXCFLAGS) $(LINUXINCLUDE) -c src/beat.c
cc $(LINUXCFLAGS) $(LINUXINCLUDE) -c src/beta.c
cc $(LINUXCFLAGS) $(LINUXINCLUDE) -c src/bilex.c
cc $(LINUXCFLAGS) $(LINUXINCLUDE) -c src/borax.c
cc $(LINUXCFLAGS) $(LINUXINCLUDE) -c src/cauchy.c
cc $(LINUXCFLAGS) $(LINUXINCLUDE) -c src/chord.c
cc $(LINUXCFLAGS) $(LINUXINCLUDE) -c src/delta.c
cc $(LINUXCFLAGS) $(LINUXINCLUDE) -c src/deny.c
cc $(LINUXCFLAGS) $(LINUXINCLUDE) -c src/dist.c
cc $(LINUXCFLAGS) $(LINUXINCLUDE) -c src/divide.c
cc $(LINUXCFLAGS) $(LINUXINCLUDE) -c src/divmod.c
cc $(LINUXCFLAGS) $(LINUXINCLUDE) -c src/edge.c
cc $(LINUXCFLAGS) $(LINUXINCLUDE) -c src/expo.c
cc $(LINUXCFLAGS) $(LINUXINCLUDE) -c src/fifo.c
cc $(LINUXCFLAGS) $(LINUXINCLUDE) -c src/gauss.c
cc $(LINUXCFLAGS) $(LINUXINCLUDE) -c src/gestalt.c
cc $(LINUXCFLAGS) $(LINUXINCLUDE) -c src/history.c
cc $(LINUXCFLAGS) $(LINUXINCLUDE) -c src/ignore.c
cc $(LINUXCFLAGS) $(LINUXINCLUDE) -c src/iso.c
cc $(LINUXCFLAGS) $(LINUXINCLUDE) -c src/lifo.c
cc $(LINUXCFLAGS) $(LINUXINCLUDE) -c src/limit.c
cc $(LINUXCFLAGS) $(LINUXINCLUDE) -c src/linear.c
cc $(LINUXCFLAGS) $(LINUXINCLUDE) -c src/listfifo.c
cc $(LINUXCFLAGS) $(LINUXINCLUDE) -c src/listfunnel.c
cc $(LINUXCFLAGS) $(LINUXINCLUDE) -c src/match.c
cc $(LINUXCFLAGS) $(LINUXINCLUDE) -c src/minus.c
cc $(LINUXCFLAGS) $(LINUXINCLUDE) -c src/mlife.c
cc $(LINUXCFLAGS) $(LINUXINCLUDE) -c src/multi.c
cc $(LINUXCFLAGS) $(LINUXINCLUDE) -c src/nchange.c
cc $(LINUXCFLAGS) $(LINUXINCLUDE) -c src/netclient.c
cc $(LINUXCFLAGS) $(LINUXINCLUDE) -c src/netdist.c
cc $(LINUXCFLAGS) $(LINUXINCLUDE) -c src/netrec.c
cc $(LINUXCFLAGS) $(LINUXINCLUDE) -c src/netserver.c
cc $(LINUXCFLAGS) $(LINUXINCLUDE) -c src/nroute.c
cc $(LINUXCFLAGS) $(LINUXINCLUDE) -c src/plus.c
cc $(LINUXCFLAGS) $(LINUXINCLUDE) -c src/pong.c
cc $(LINUXCFLAGS) $(LINUXINCLUDE) -c src/poisson.c
cc $(LINUXCFLAGS) $(LINUXINCLUDE) -c src/pulse.c
cc $(LINUXCFLAGS) $(LINUXINCLUDE) -c src/pitch.c
cc $(LINUXCFLAGS) $(LINUXINCLUDE) -c src/remote.c
cc $(LINUXCFLAGS) $(LINUXINCLUDE) -c src/rewrap.c
cc $(LINUXCFLAGS) $(LINUXINCLUDE) -c src/rhythm.c
cc $(LINUXCFLAGS) $(LINUXINCLUDE) -c src/scale.c
cc $(LINUXCFLAGS) $(LINUXINCLUDE) -c src/score.c
cc $(LINUXCFLAGS) $(LINUXINCLUDE) -c src/speedlim.c
cc $(LINUXCFLAGS) $(LINUXINCLUDE) -c src/split.c
cc $(LINUXCFLAGS) $(LINUXINCLUDE) -c src/step.c
cc $(LINUXCFLAGS) $(LINUXINCLUDE) -c src/subst.c
cc $(LINUXCFLAGS) $(LINUXINCLUDE) -c src/sync.c
cc $(LINUXCFLAGS) $(LINUXINCLUDE) -c src/temperature.c
cc $(LINUXCFLAGS) $(LINUXINCLUDE) -c src/tilt.c
cc $(LINUXCFLAGS) $(LINUXINCLUDE) -c src/timebang.c
cc $(LINUXCFLAGS) $(LINUXINCLUDE) -c src/triang.c
cc $(LINUXCFLAGS) $(LINUXINCLUDE) -c src/unroute.c
cc $(LINUXCFLAGS) $(LINUXINCLUDE) -c src/urn.c
cc $(LINUXCFLAGS) $(LINUXINCLUDE) -c src/velocity.c
cc $(LINUXCFLAGS) $(LINUXINCLUDE) -c src/weibull.c
cc $(LINUXCFLAGS) $(LINUXINCLUDE) -c src/wrap.c
cc $(LINUXCFLAGS) $(LINUXINCLUDE) -c $*.c
ld -export_dynamic -shared -o $*.pd_linux $*.o $(LINUXEXTERNALS) -lc
strip --strip-unneeded $*.pd_linux
# ----------------------------------------------------------
PDDIR=/usr/local/lib/pd
install:
install -d $(PDDIR)/doc/5.reference/maxlib
cp help/help-*.pd $(PDDIR)/doc/5.reference/maxlib
clean:
rm -f *.o *.pd_* so_locations
--- NEW FILE: HISTORY ---
version history of maxlib library for pure-data
v 1.5.2 (17. december 2003):
- modified netclient for not to drop received data: use of syspollfn
instead of clock to poll for incoming data, circular recv buffer
v 1.5 (18. october 2003):
- added some usefull features to arraycopy (i.e. copying just parts of
an array and copying to specified position in destination array)
- new object: nchange
- IRIX 6.5 port (for GCC 3.3)
- OS X binary (Jaguar 10.2.6)
v 1.4 (22. may 2003):
- updated sources to compile with Pd0.37-test4
- new object: arraycopy
v 1.3 (12. april 2003):
- new objects: sync listfifo
- all setup routines renamed to maxlib_<object>_setup() to avoid name
clashes, old names still work via class_addcreator()
- some improvements for the help files
v 1.2 (30. january 2003):
- new objects: unroute urn split wrap rewrap timebang
- another fix for the makefile
- fixed a bug in netserver (sockets remained open when netserver closed)
- added a 'prepend' option (with additional creation argument) to remote,
patch was supplied by Maurizio Umberto Puxeddu
v 1.1b2 (23. oktober 2002):
- corrected two small bugs in the makefile (linux only!), thanks to
Hans-Christoph Steiner
v 1.1b (12. september 2002):
- new object: limit
- match and speedlim have been replaced with the objects from cyclone library
- deleted the (unwanted) debugging printout from nroute
v 1.1 (26. august 2002):
- new objects: nroute, pong, edge
- arbran 0.1b now allows to (re-)set the arrays dynamically
- match 0.3 now matches any type of data (floats, lists, symbols, anything)
- scale 0.2 allows to dynamically change the creation arguments and to choose
between linear (default) and exponential scale
- MSVC++ workspace contains configuration for Intel Compiler with Pentium 4
optimizations ("maxlib - Win32 Intel")
- makefile and binary release for Mac OS X (10.1.5)
- BUG FIX: corrected path to helpfiles in rand objects
- BUG FIX: corrected makefile to work under Linux again
v 1.0 (9th august 2002):
- new objects: netserver, netclient, arbran, beta, bilex, cauchy, expo,
gauss, linear, poisson, triang, weibull
- the help patches now live in doc/5.reference/maxlib, thanks to
Frank Barknecht for suggesting that and for modifying the sources
v 0.9 (25th july 2002):
- new objects: tilt gestalt temperature
v 0.8b (21st july 2002):
- now compiles on Linux, thanks to Martin Pi
- new objects: listfunnel
v 0.8 (4th july 2002):
- new objects: history netrec scale delta velocity
- some small changes to speedlim
v 0.7 (24th june 2002):
- fixed a bug in average, thanks to João Miguel Pais
- new chord algorhythm: supports up to 67 chord types now
v 0.6 (7th june 2002):
- added objects: beat rhythm
v 0.5 (28th mai 2002):
- added objects: netdist mlife subst
- netdist uses the pthreads-win32 library for POSIX multithreading
under NT, thus at least pd0.35-test17 is needed under NT
- made a MSVC++ 6.0 project file
v 0.4 (16th mai 2002):
- match now also takes lists of floats
- added objects: dist remote step
v 0.3b (14th mai 2002):
- fixed a zero-division bug in pulse, thanks to Frank Barknecht
v 0.3 (13th mai 2002):
- added objects: divmod, fifo, iso, lifo, pulse
- made divide, minus, multi & plus 'multi-inlet-ready'
v 0.2 (7th mai 2002):
- added objects: average, chord, score
v 0.1b (24th apr. 2002):
- added objects: divide, minus, multi, plus
v 0.1a (15th apr. 2002, first public release):
- included objects: borax, ignore, match, pitch, speedlim
1
0
Update of /cvsroot/pure-data/externals/maxlib/help
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv2641/help
Added Files:
automata.txt examplescore.txt help-allow.pd help-arbran.pd
help-arraycopy.pd help-average.pd help-beat.pd help-beta.pd
help-bilex.pd help-borax.pd help-cauchy.pd help-chord.pd
help-delta.pd help-deny.pd help-dist.pd help-divide.pd
help-divmod.pd help-edge.pd help-expo.pd help-fifo.pd
help-gauss.pd help-gestalt.pd help-history.pd help-ignore.pd
help-iso.pd help-lifo.pd help-limit.pd help-linear.pd
help-listfifo.pd help-listfunnel.pd help-match.pd
help-maxlib.pd help-minus.pd help-mlife.pd help-multi.pd
help-nchange.pd help-netclient.pd help-netdist.pd
help-netrec.pd help-netserver.pd help-nroute.pd help-pitch.pd
help-plus.pd help-poisson.pd help-pulse.pd help-remote.pd
help-rewrap.pd help-rhythm.pd help-scale.pd help-score.pd
help-speedlim.pd help-split.pd help-step.pd help-subst.pd
help-sync.pd help-temperature.pd help-tilt.pd help-timebang.pd
help-triang.pd help-unroute.pd help-urn.pd help-velocity.pd
help-weibull.pd help-wrap.pd
Log Message:
things back to Olaf's 1.5.2
--- NEW FILE: help-divide.pd ---
#N canvas 328 264 466 318 12;
#X floatatom 54 217 5 0 0;
#X floatatom 54 132 5 0 0;
#X floatatom 108 132 5 0 0;
#X text 39 20 divide :: like '/' but calculates result;
#X text 133 204 use creation arguments to set initial;
#X text 133 220 values for inlets;
#X msg 7 104 bang;
#X text 53 103 calculate and output result now;
#X obj 54 172 divide 8 6 4;
#X text 118 58 allows for up to 32 inlets;
#X floatatom 164 132 5 0 0;
#X text 120 38 when leftmost or second inlet is changed;
#X connect 1 0 8 0;
#X connect 2 0 8 1;
#X connect 6 0 8 0;
#X connect 8 0 0 0;
#X connect 10 0 8 2;
--- NEW FILE: help-bilex.pd ---
#N canvas 370 195 485 306 12;
#X obj 70 95 bng 20 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
-1;
#X floatatom 70 192 5 0 0;
#X floatatom 177 103 5 0 0;
#X text 230 105 lambda;
#X text 13 20 bilex :: bilinear exponetionally distributed random
numbers;
#X obj 70 140 bilex 1.5;
#X connect 0 0 5 0;
#X connect 2 0 5 1;
#X connect 5 0 1 0;
--- NEW FILE: help-limit.pd ---
#N canvas 328 32 558 365 12;
#X floatatom 27 277 8 0 0;
#X floatatom 27 73 5 0 0;
#X text 215 46 written by <olaf.matthes(a)gmx.de>;
#X floatatom 54 131 5 0 0;
#X floatatom 82 152 5 0 0;
#X floatatom 110 173 5 0 0;
#X text 84 71 input value;
#X text 57 104 creation arguments can be changed dynamically:;
#X obj 27 249 limit 0 9 5;
#X text 35 316 creation arguments:;
#X text 170 172 0 = limit \, others: compression ratio;
#X text 35 340 limit <lower limit> <upper limit> <ratio>;
#X text 324 195 values between 0 and 1;
#X text 325 213 result in expansion !;
#X text 106 278 limited / compressed output value;
#X text 141 11 limit :: limits input to lie between boundaries;
#X text 213 27 allows for compression / expansion;
#X text 114 129 lower boundary;
#X text 144 151 upper boundary;
#X connect 1 0 8 0;
#X connect 3 0 8 1;
#X connect 4 0 8 2;
#X connect 5 0 8 3;
#X connect 8 0 0 0;
--- NEW FILE: help-netserver.pd ---
#N canvas 246 114 752 474 12;
#X floatatom 49 333 5 0 0;
#X floatatom 87 298 5 0 0;
#X symbolatom 164 251 10 0 0;
#X text 102 332 received data;
#X text 140 298 number of connections;
#X msg 49 54 print;
#X floatatom 125 272 5 0 0;
#X text 183 276 socket number;
#X msg 103 179 broadcast hallo world!;
#X text 288 179 send to all clients;
#X text 144 33 written by Olaf Matthes <olaf.matthes(a)gmx.de>;
#X obj 49 223 netserver 3000;
#X text 137 120 send message to client no. 1;
#X text 256 251 client's IP address;
#X obj 477 189 netclient;
#X msg 498 116 connect localhost 3000;
#X msg 511 143 disconnect;
#X msg 477 84 send 23;
#X floatatom 544 218 5 0 0;
#X msg 83 91 send 380 17.3;
#X floatatom 477 296 5 0 0;
#X obj 600 281 print anything;
#X obj 538 309 print list;
#X obj 477 245 route float list;
#X msg 98 142 client 1 23;
#X text 204 91 "send <socketnumber> <data>";
#X text 110 70 send message on specified socket;
#X text 200 143 "client <clientnumber> <data>";
#X text 48 379 This example demonstrates how to set up a client/server
connection. Data sent by the client get's received and displayed by
the server imediately. Or just try it the other way round...;
#X text 38 15 netclient :: simple client that connects to netserver
;
#X connect 5 0 11 0;
#X connect 8 0 11 0;
#X connect 11 0 0 0;
#X connect 11 1 1 0;
#X connect 11 2 6 0;
#X connect 11 3 2 0;
#X connect 14 0 23 0;
#X connect 14 1 18 0;
#X connect 15 0 14 0;
#X connect 16 0 14 0;
#X connect 17 0 14 0;
#X connect 19 0 11 0;
#X connect 23 0 20 0;
#X connect 23 1 22 0;
#X connect 23 2 21 0;
#X connect 24 0 11 0;
--- NEW FILE: help-lifo.pd ---
#N canvas 356 196 454 304 12;
#X obj 38 176 lifo 10;
#X floatatom 38 231 5 0 0;
#X floatatom 61 110 5 0 0;
#X msg 38 76 bang;
#X text 83 76 hit to get next number;
#X text 111 176 lifo <size>;
#X text 42 14 lifo :: last in first out buffer for floats;
#X text 108 33 written for Max by St. Rainstick;
#X msg 76 140 clear;
#X text 127 139 clear buffer;
#X text 92 233 output of buffer;
#X connect 0 0 1 0;
#X connect 2 0 0 0;
#X connect 3 0 0 0;
#X connect 8 0 0 0;
--- NEW FILE: help-delta.pd ---
#N canvas 328 264 466 318 12;
#X floatatom 54 217 5 0 0;
#X floatatom 54 108 5 0 0;
#X msg 23 83 bang;
#X text 69 82 calculate and output result now;
#X obj 54 172 delta;
#X obj 54 133 * 3;
#X floatatom 127 218 5 0 0;
#X floatatom 127 109 5 0 0;
#X obj 127 134 * 3;
#X obj 127 173 delta 2;
#X text 53 259 use creation arguments to set order (1st or 2nd);
#X text 39 20 delta :: calculate 1st or 2nd order difference;
#X connect 1 0 5 0;
#X connect 2 0 4 0;
#X connect 4 0 0 0;
#X connect 5 0 4 0;
#X connect 7 0 8 0;
#X connect 8 0 9 0;
#X connect 9 0 6 0;
--- NEW FILE: help-netclient.pd ---
#N canvas 246 114 752 474 12;
#X floatatom 49 333 5 0 0;
#X floatatom 87 298 5 0 0;
#X symbolatom 164 251 10 0 0;
#X text 102 332 received data;
#X text 140 298 number of connections;
#X msg 49 54 print;
#X floatatom 125 272 5 0 0;
#X text 183 276 socket number;
#X msg 103 179 broadcast hallo world!;
#X text 288 179 send to all clients;
#X text 143 49 written by Olaf Matthes <olaf.matthes(a)gmx.de>;
#X obj 49 223 netserver 3000;
#X text 137 120 send message to client no. 1;
#X text 256 251 client's IP address;
#X obj 477 189 netclient;
#X msg 498 116 connect localhost 3000;
#X msg 511 143 disconnect;
#X msg 477 84 send 23;
#X floatatom 544 218 5 0 0;
#X msg 83 91 send 380 17.3;
#X floatatom 477 296 5 0 0;
#X obj 600 281 print anything;
#X obj 538 309 print list;
#X obj 477 245 route float list;
#X msg 98 142 client 1 23;
#X text 204 91 "send <socketnumber> <data>";
#X text 110 70 send message on specified socket;
#X text 200 143 "client <clientnumber> <data>";
#X text 48 379 This example demonstrates how to set up a client/server
connection. Data sent by the client get's received and displayed by
the server imediately. Or just try it the other way round...;
#X text 38 15 netclient :: simple client that connects to netserver
or;
#X text 142 32 to pd's native netreceive object;
#X connect 5 0 11 0;
#X connect 8 0 11 0;
#X connect 11 0 0 0;
#X connect 11 1 1 0;
#X connect 11 2 6 0;
#X connect 11 3 2 0;
#X connect 14 0 23 0;
#X connect 14 1 18 0;
#X connect 15 0 14 0;
#X connect 16 0 14 0;
#X connect 17 0 14 0;
#X connect 19 0 11 0;
#X connect 23 0 20 0;
#X connect 23 1 22 0;
#X connect 23 2 21 0;
#X connect 24 0 11 0;
--- NEW FILE: help-expo.pd ---
#N canvas 370 195 454 304 12;
#X obj 70 95 bng 20 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
-1;
#X floatatom 70 192 5 0 0;
#X text 13 20 expo :: exponetionally distributed random numbers
;
#X obj 70 140 expo 0.5;
#X floatatom 169 101 5 0 0;
#X text 222 103 lambda;
#X connect 0 0 3 0;
#X connect 3 0 1 0;
#X connect 4 0 3 1;
--- NEW FILE: help-rewrap.pd ---
#N canvas 328 32 564 467 12;
#X floatatom 27 304 8 0 0 0 - - -;
#X floatatom 27 73 5 0 0 0 - - -;
#X text 202 47 written by <olaf.matthes(a)gmx.de>;
#X floatatom 60 133 5 0 0 0 - - -;
#X floatatom 94 158 5 0 0 0 - - -;
#X text 84 71 input value;
#X text 57 102 creation arguments can be changed dynamically:;
#X text 35 341 creation arguments:;
#X text 115 132 lower limit;
#X text 146 157 upper limit;
#X floatatom 110 276 5 0 0 0 - - -;
#X text 36 358 wrap <lower limit> <upper limit>;
#X obj 27 249 rewrap 6 40;
#X text 200 27 into a range;
#X text 169 275 wrap period;
#X text 107 305 output;
#X text 122 11 rewrap :: wraps floats back and forth;
#X connect 1 0 12 0;
#X connect 3 0 12 1;
#X connect 4 0 12 2;
#X connect 12 0 0 0;
#X connect 12 1 10 0;
--- NEW FILE: automata.txt ---
[The following note originally appeared on the emusic-l mailing list. It is
reprinted here with the author's permission]
>From xrjdm(a)FARSIDE.GSFC.NASA.GOV Wed Nov 23 11:26:39 1994
Date: Tue, 4 Oct 1994 15:09:23 -0500
From: Joe McMahon <xrjdm(a)FARSIDE.GSFC.NASA.GOV>
Reply to: Electronic Music Discussion List <EMUSIC-L(a)AMERICAN.EDU>
To: Multiple recipients of list EMUSIC-L <EMUSIC-L(a)AMERICAN.EDU>
Subject: Automata: the long-awaited summary
Back in August, I think, I promised to post a quick intro to cellular
automata and how they can be used as a sound-generation tool. Since I'm
going to take a couple of different sources and sum them up with little or
no direct attribution, combined with my own opinions, I'll give everybody
my references *first* so they can delete the article and draw their own
conclusions if they so prefer.
The primary reference that got me started on all this is one in the CMJ:
Vol 14, No. 4, Winter 1990: "Digital Synthesis of Self-modifying Waveforms
by Means of Cellular Automata" (Jacques Chareyon). Those who are already
familiar with automata may just skip to that article and forget about the
rest of this one.
Note: the article gives a mail address for M. Chareyon, but he did not
answer an inquiry about any available recordings using this technique in
1990.
So. Anyone still here? Good.
Cellular automata are a mathematical concept first introduced in the late
1940's. Generally speaking, a cellular automaton consists of a grid of
cells. Each cell may take on any of a number of values - binary automata
(cell on or cell off) are the most commonly studied. Each cell has a
neighborhood, defined more simply as other cells which influence its state.
The exact nature of this influence is defined by what are called transition
rules. The cellular automaton starts off with some cells in any of the
allowable states. for each "step" in the automaton's history, the
neighborhood of every cell is checked, and the state of the cell is
updated. All updates occur simultaneously.
The transition rule must describe the resulting state of a cell for every
possible configuration of other cells in the neighborhood. For large
numbers of states, the amount of memory required to hold the transition
rule becomes increasingly large, Therefore, some automata use what is known
as a "totalistic" rule. These rules simply sum the values of the cells in
the neighborhood and then assign a result on this basis. The resulting
tables are far smaller.
Many readers may already be familiar with John Horton Conway's game of
"Life". This is a two-dimensional binary automaton with a totalistic rule.
This makes for a very small rule set:
i) If fewer than two filled cells (cells with value 1) surround a cell,
it becomes empty next generation.
ii) If more than three filled cells surround a cell, it becomes empty
next generation.
iii) If exactly three cells filled cells surround a cell, it becomes
filled on the next generation.
This corresponds to a totalistic rule set with a total of 8(2-1)+1 or 9
rules (one each for the sum values of 0 (no cells with a value) through 9
(all cells with a value) ).If the transition rule were represented as a
non-totalistic one, the rule set would need 2**8 or 256 entries. There are
many interesting totalistic automata, so giving up detailed description of
every nuance of the transitions to save memory space isn't a big sacrifice.
Interesting as two dimensional automata are, they really aren't terribly
useful for music making. There have been some experiments which have
attempted to use a two-dimensional automaton to generate MIDI events -
synthesis at the note level, using :
Battista, T. and M. Giri, 1988. "Composizione Tramite Automi Cellulari."
Atti del VII Cooloquio di Informatica Musicale. Rome, Italy: Edizione Arti
Grafiche Ambrosini, pp. 181-182.
Edgar, R. and J. Ryan, 1986. "LINA" Exhibition of the 1986 International
Computer Music Conference, San Francisco: Computer Music Association.
I have not heard any of the music from these efforts, so I certainly can't
pass any judgement on them. For the purposes of this summary, we'll just
look at one-dimensional automata. These use a linear array of cells, with
the neighborhood generally being one or two cells on either side of each
cell.
(This is the type of automaton dealt with in M. Chareyon's article, which I
will be paraphrasing broadly hereafter).
M. Chareyon's automata are wavetables. A digitized signal is stored as a
linear array of numbers in memory. A totalistic rule is used to determine a
lookup value which indexes into an array containing the resulting value;
this is saved into a second array. After the first array is completely
processed, the roles of the two are swapped and the process is repeated.
The limiting factor in this process is the number of bits of resolution
being used to generate the sound. For a totalistic rule using a two-cell
neighborhood and 12-bit individual samples, we have 3*(2*12) = 12288
entries in the rule table. At 2 bytes each, this is 24K of storage. If we
go to 16-bit sample resolution, we have 196608 entries at 2 bytes each for
a total of 393216 bytes, or 384K.
The key point of M. Charyeon's method is the use of small neighborhoods
with large numbers of cellular states. Since the computation of the new
wavetable is all table lookup, very complex transition rules can be
precomputed and loaded into the tables, allowing the synthesis to
essentially be a fast sum-and-lookup loop to calculate each new wavesample.
>From the article, it appears that M. Chareyon was able to produce 2 or 3
voices in realtime on a Mac II with a Digidesign Sound Accelerator board.
It seems that it would probably be possible to use an AV Mac to do it
without the board.
This LASy (Linear Automaton Synthesis) method is closely related to the
Karplus-Strong plucked-string algorithm, in that a wavesample is run
through an algorithm which recirculates the samples to "self-modify" the
wave. In fact, a judicious choice of table entries allows one to very
simply simulate the K-S algoritm directly.
So what are the sounds like? Some automata produce waveforms which quickly
"ramp-up" to complex spectra and then drop off quickly. Others move to a
steady state and then remain there. Yet others produce never-ending and
unpredictable waveforms, whose harmonic content is constantly changing.
Obviously enough, the original wavesample can be obtained mathematically,
or by actual sampling and using LASy as a waveshaper. As M. Chareyon notes,
a quick estimate of the number of possible automata for a 2-neighbor
totalistic rule using a 256-entry wavetable with 12-bit entries is
(2**12)**256 * (2**12)**(3*2**12) or about 10**4500 possible automata. Of
course, many, many of these would not be suitable for music (e.g., the 4096
automata in which all values go to one vlaue in one step, etc.); however,
the number of musically useful automata is still likely to be an immense
number.
M. Chareyon provides a number of examples of ways to fill out the rule
tables and a number of hints on creating wave tables - generally speaking,
one can create a function which is used to compute the values to be placed
into the table and then fill it so it can simply be loaded and used by the
basic algorithm. His experience in using LASy is that he manages
approximately 50% of the time to produce sounds with the desired
characteristics, and that about 10% of the remaining time he gets
unexpected but useful results which can be used as starting points for
further exploration.
Again, the important point is that the basic automaton uses wavesamples at
full resolution, calculating a new wavesample for each step of the
automaton; the next wavesample can be played while the new one is being
calculated. Because of the large number of states, mathematical tools for
the analysis of automata and the construction of automata with specifically
desired qualities require too much storage and compute time to make them
useful for LASy purposes.
Again, much of this article is paraphrased from M. Chareyon's article; I
take no credit for any of the work in this note. I'm just summarizing.
The following other articles were referenced by M. Chareyon's article:
Burks, A., ed. 1970. Essays on Cellular Automata. Champaign/Urbana, IL:
University of Illinois Press.
Chareyon, J. 1988a. "Sound Synthesis and Processing by Means of Linear
Cellular Automata." Proceedings of the 1988 Internation Computer Music
Conference. San Francisco: Computer Music Association.
Chareyon, J. 1988b. "Wavetable come Automa Cellulare: una Nuova Tecnica di
Sintesi." Atti del VII Colloquio di Informatica Musicale, Rome, Italy:
Edizioni Arti Grafiche Ambrosini, pp. 174-177.
Farmer, D., T. Toffoli, and S. Wolfram, eds. 1984. Cellular Automata.
North-Holland Physics Publishing. [One of the definitive works on cellular
automata - fairly heavy math, not a popular presentation - JM]
Gardner, M. 1970. "The Fantastic Combinations of John Conway's New Solitare
Game 'Life'". Scientific American 223(4) 120-123. [A good introduction to
cellular automata, focusing on 'life' in specific. Useful intro if my
1-paragraph summary of automata was confusing :) - JM]
--- Joe M.
--
"At the end of the hour, we'll have information on the sedatives used by
the artists,,," (MST3K)
--- NEW FILE: examplescore.txt ---
60
61
62
63
64
65
66
67
68
69
70
71
72
71
70
69
68
67
66
65
64
63
62
61
60
--- NEW FILE: help-deny.pd ---
#N canvas 358 305 556 310 12;
#X text 97 34 written by Olaf Matthes <olaf.matthes(a)gmx.de>;
#X msg 125 65 cat;
#X msg 147 97 dog;
#X msg 157 126 bird;
#X floatatom 82 269 5 0 0 0 - - -;
#X symbolatom 151 246 10 0 0 0 - - -;
#X obj 114 156 symbol \$1;
#X floatatom 40 81 5 0 0 0 - - -;
#X obj 82 217 route float symbol;
#X obj 82 189 deny 17 cat dog 23;
#X text 32 18 deny :: blocks 'denyed' floats or symbols;
#X connect 1 0 6 0;
#X connect 2 0 6 0;
#X connect 3 0 6 0;
#X connect 6 0 9 0;
#X connect 7 0 9 0;
#X connect 8 0 4 0;
#X connect 8 1 5 0;
#X connect 9 0 8 0;
--- NEW FILE: help-maxlib.pd ---
#N canvas 75 -12 1161 819 10;
#X obj 307 260 average;
#X obj 18 150 beat;
#X obj 18 175 borax;
#X obj 18 125 chord;
#X obj 14 588 dist;
#X obj 307 155 divide;
#X obj 307 129 divmod;
#X obj 656 148 fifo;
#X obj 307 286 history;
#X obj 403 577 ignore;
#X obj 403 552 iso;
#X obj 655 122 lifo;
#X obj 307 312 match;
#X obj 307 180 minus;
#X obj 660 343 mlife;
#X obj 307 207 multi;
#X obj 14 613 netdist;
#X obj 18 251 pitch;
#X obj 307 234 plus;
#X obj 403 499 pulse;
#X obj 14 637 remote;
#X obj 18 200 rhythm;
#X obj 18 225 score array01;
#X obj 403 525 speedlim;
#X obj 403 603 step;
#X obj 660 318 subst;
#X text 140 44 written by Olaf Matthes <olaf.matthes(a)gmx.de>;
#X text 71 125 chord detection;
#X text 68 150 beat tracking;
#X text 77 201 beat detection;
#X text 72 176 music analysis;
#X text 135 225 score following;
#X text 72 251 pitch information;
#X text 19 94 MUSIC / MIDI ANALYSIS;
#X text 310 91 MATH;
#X text 374 130 calculate / and %;
#X text 372 155 / for several inputs;
#X text 366 235 + for several inputs;
#X text 366 207 * for several inputs;
#X text 370 181 - for several inputs;
#X text 378 259 average of last N values;
#X text 379 285 average over last N seconds;
#X text 362 312 match input to list of numbers;
#X text 403 473 TIME;
#X text 480 526 lets input through every N milliseconds;
#X text 442 553 play sequence of MIDI notes;
#X text 464 578 ignore too fast changing input;
#X text 62 587 send to list of receive objects;
#X text 83 611 same for netreceive;
#X text 73 636 send to one receive object;
#X text 654 95 BUFFER;
#X text 450 605 a line object that steps;
#X text 659 294 OTHER / EXPERIMENTAL;
#X text 717 317 self-similar substitution;
#X text 716 343 cellular automaton;
#X obj 307 338 scale;
#X text 458 499 a 'better' metro;
#X obj 403 629 history;
#X obj 403 655 velocity;
#X text 472 629 average over last N milliseconds;
#X text 479 655 velocity of input in digits per second;
#X obj 14 661 netrec;
#X text 73 662 netreceive with extra info about sender;
#X obj 307 364 delta;
#X text 139 61 download at http://www.akustische-kunst.org/puredata/maxlib
;
#X obj 656 173 listfifo;
#X text 734 172 first in first out for lists;
#X text 703 147 first in first out for floats;
#X text 700 122 last in first out for floats;
#X obj 402 681 sync;
#X text 447 683 extended trigger object;
#X text 361 338 scale input to output range;
#X text 12 565 (REMOTE)CONTROL;
#X obj 15 686 netserver;
#X obj 15 713 netclient;
#X text 102 691 bidirectional communication;
#X text 111 706 (client / server based);
#X obj 307 392 wrap;
#X obj 307 419 rewrap;
#X text 353 392 warp a number in a range;
#X text 370 420 warp it back and forth;
#X text 361 364 calculate 1st or 2nd order diff.;
#X text 660 374 RANDOM;
#X obj 660 398 gauss;
#X obj 660 423 poisson;
#X obj 726 398 linear;
#X obj 726 423 bilex;
#X obj 796 397 expo;
#X obj 845 397 beta;
#X obj 894 398 cauchy;
#X obj 797 424 arbran array01 array02;
#X obj 18 278 gestalt;
#X obj 18 303 edge;
#X text 66 307 detect rising/falling edge;
#X text 84 278 'gestalt' of music;
#X obj 659 452 urn;
#X text 692 452 urn selection model;
#X obj 403 709 timebang;
#X text 482 709 send a bang at given time of day;
#X obj 15 390 split;
#X obj 15 439 unroute;
#X text 81 440 opposit to route;
#X text 74 392 split according to range;
#X obj 15 463 limit;
#X text 63 464 limiter for floats;
#X obj 15 415 nroute;
#X text 80 414 r. according to Nth elem.;
#X text 24 363 ROUTING / CHECKING;
#X obj 402 735 pong;
#X obj 18 330 tilt;
#X obj 402 760 temperature;
#X text 500 761 amount of input changes per time;
#X text 448 736 a bouncing ball model;
#X text 66 333 meassure tilt of input;
#X obj 16 489 listfunnel;
#X text 107 490 Max's funnel for lists;
#X text 30 26 maxlib 1.5 :: Music Analysis eXtensions LIBrary;
#X obj 656 201 arraycopy;
#X text 741 202 copy from one array to another;
#X obj 17 525 nchange s;
#X text 89 526 change that exepts any kind of input;
--- NEW FILE: help-ignore.pd ---
#N canvas 445 253 464 314 12;
#X floatatom 47 107 5 0 0;
#X floatatom 47 225 5 0 0;
#X text 122 197 creation argument = time in ms;
#X floatatom 122 136 5 0 0;
#X obj 47 167 ignore 500;
#X text 177 136 time in ms a value has to;
#X text 178 152 be present in order to get through;
#X text 75 24 ignore :: lets information through;
#X text 154 41 only when it was presente;
#X text 155 59 at input longer than N ms;
#X text 73 258 note: input gets delayed by N milliseconds;
#X connect 0 0 4 0;
#X connect 3 0 4 1;
#X connect 4 0 1 0;
--- NEW FILE: help-average.pd ---
#N canvas 445 253 470 320 12;
#X floatatom 47 39 5 0 0;
#X floatatom 47 276 5 0 0;
#X floatatom 122 191 5 0 0;
#X obj 47 219 average 10;
#X text 177 191 number of items to average;
#X text 139 220 creation argument = number of items;
#X floatatom 122 254 5 0 0;
#X text 105 277 average of last N items;
#X text 125 11 average :: calculates the average of the;
#X text 214 30 last N items (floats);
#X text 176 255 tendency (up = 1 \, down = -1);
#X msg 100 60 reset;
#X text 152 61 forget everything;
#X msg 129 94 linear;
#X msg 147 118 geometric;
#X text 191 93 linear average (dafault);
#X text 230 119 geometric average;
#X msg 158 146 weight;
#X text 217 147 weighted average (giving last;
#X text 218 163 items higher weight);
#X connect 0 0 3 0;
#X connect 2 0 3 1;
#X connect 3 0 1 0;
#X connect 3 1 6 0;
#X connect 11 0 3 0;
#X connect 13 0 3 0;
#X connect 14 0 3 0;
#X connect 17 0 3 0;
--- NEW FILE: help-beta.pd ---
#N canvas 438 222 487 308 12;
#X obj 70 95 bng 20 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
-1;
#X floatatom 70 192 5 0 0;
#X floatatom 139 94 5 0 0;
#X obj 70 140 beta 0.78 1.3;
#X text 192 95 a;
#X floatatom 209 116 5 0 0;
#X text 262 117 b;
#X text 39 21 beta :: beta distributed random numbers;
#X connect 0 0 3 0;
#X connect 2 0 3 1;
#X connect 3 0 1 0;
#X connect 5 0 3 2;
--- NEW FILE: help-sync.pd ---
#N canvas 142 53 830 657 12;
#X text 78 16 sync :: extended trigger object based;
#X text 143 35 on sync from jMax;
#X floatatom 18 485 5 0 0 0 - - -;
#X floatatom 39 457 5 0 0 0 - - -;
#X floatatom 61 433 5 0 0 0 - - -;
#X floatatom 18 124 5 0 0 0 - - -;
#X floatatom 39 152 5 0 0 0 - - -;
#X floatatom 61 177 5 0 0 0 - - -;
#X msg 205 143 mode any;
#X msg 187 116 mode all;
#X msg 216 169 mode left;
#X msg 229 198 mode right;
#X msg 243 226 mode none;
#X text 295 142 any input triggers the outputs;
#X text 305 169 trigger output when left inlet changes;
#X text 325 199 trigger output when right inlet changes;
#X text 333 228 never trigger output;
#X obj 18 404 sync 3;
#X text 146 415 the creation argument determines the number of inlets
/ outlets sync will have.;
#X obj 149 462 sync 23 17.3;
#X text 147 490 alternatively it's possible to specify the number of
inlets / outlets by giving initial values for every outlet. these values
will be output in case no input has been received in the corresponding
inlet until the time when the output is triggered.;
#X text 274 116 all inputs have to change to trigger output (default)
;
#X msg 223 270 trigger 2;
#X msg 230 335 require 1;
#X text 324 320 additionally another input can be defined to be required
for the trigger event to take place. i.e. the second inlet (inlet #1)
from the left must have been changed since the last triggering occured.
;
#X text 324 265 use this message to make the n-th input (counting from
0 to <number of inputs - 1>) a triggering input. only one input at
a time can be triggering!;
#X text 212 90 the easy way:;
#X msg 228 299 trigger 1;
#X connect 5 0 17 0;
#X connect 6 0 17 1;
#X connect 7 0 17 2;
#X connect 8 0 17 0;
#X connect 9 0 17 0;
#X connect 10 0 17 0;
#X connect 11 0 17 0;
#X connect 12 0 17 0;
#X connect 17 0 2 0;
#X connect 17 1 3 0;
#X connect 17 2 4 0;
#X connect 22 0 17 0;
#X connect 23 0 17 0;
#X connect 27 0 17 0;
--- NEW FILE: help-urn.pd ---
#N canvas 0 0 462 312 12;
#X obj 99 182 urn 8;
#X msg 157 112 clear;
#X floatatom 99 241 5 0 0 0 - - -;
#X msg 99 85 bang;
#X obj 189 241 bng 20 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
-1;
#X text 144 85 choose next number;
#X text 209 113 clear / refill urn;
#X floatatom 149 150 5 0 0 0 - - -;
#X text 201 150 change number of items in urn;
#X text 69 30 urn :: urn selection model;
#X text 221 241 bang if urn is empty;
#X connect 0 0 2 0;
#X connect 0 1 4 0;
#X connect 1 0 0 0;
#X connect 3 0 0 0;
#X connect 7 0 0 1;
--- NEW FILE: help-rhythm.pd ---
#N canvas 262 64 579 413 12;
#X obj 25 273 rhythm 0;
#X floatatom 25 356 5 0 0;
#X obj 25 59 notein;
#X obj 348 237 makenote 100 100;
#X msg 348 209 60;
#X floatatom 54 328 5 0 0;
#X text 81 360 beats per minute;
#X text 111 331 beats in milliseconds;
#X msg 79 113 reset;
#X msg 90 146 model 0;
#X msg 96 175 model 1;
#X text 158 147 Large and Kolen adaptation model;
#X text 164 174 Toiviainen adaptation model;
#X text 53 21 rhythm :: detects the beat of rhythmic patterns;
#X text 134 39 written by Olaf Matthes <olaf.matthes(a)gmx.de>;
#X text 134 56 based on code written by Rober Rowe and published;
#X text 133 72 in 'Mashine musicianship' \, Massachusetts \, 2001;
#X text 115 275 creation: rhythm <adaptation model>;
#X obj 84 303 bng 20 100 10 0 empty empty empty 0 -6 0 8 -262144 -42246
-1;
#X text 115 304 beat pulse;
#X text 132 114 reset all values \, forget rhythm and stop beat pulse
;
#X connect 0 0 1 0;
#X connect 0 1 5 0;
#X connect 0 2 18 0;
#X connect 2 0 0 0;
#X connect 2 1 0 1;
#X connect 3 0 0 0;
#X connect 3 1 0 1;
#X connect 4 0 3 0;
#X connect 8 0 0 0;
#X connect 9 0 0 0;
#X connect 10 0 0 0;
--- NEW FILE: help-borax.pd ---
#N canvas 281 85 645 549 12;
#X obj 125 230 bng 20 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
-1;
#X floatatom 125 298 6 0 0;
#X floatatom 50 451 5 0 0;
#X floatatom 26 502 5 0 0;
#X floatatom 63 425 5 0 0;
#X floatatom 38 476 5 0 0;
#X floatatom 100 349 6 0 0;
#X floatatom 75 399 5 0 0;
#X floatatom 112 323 5 0 0;
#X floatatom 87 374 5 0 0;
#X obj 26 269 borax 0 0 0 0;
#X text 103 452 number of voices currently playing;
#X text 120 422 pitch;
#X text 127 399 velocity;
#X obj 15 54 makenote 100 1500;
#X obj 336 67 metro 100;
#X obj 428 124 + 50;
#X obj 428 147 s time;
#X obj 403 43 r time;
#X obj 260 147 s pitch;
#X obj 15 17 r pitch;
#X obj 80 18 r velo;
#X msg 336 14 1;
#X msg 345 37 0;
#X obj 513 101 random 64;
#X obj 513 124 + 64;
#X obj 513 147 s velo;
#X obj 146 19 r duration;
#X obj 336 147 s duration;
#X obj 336 124 + 250;
#X text 91 477 voice allocation number - each note playing is assigned
a no;
#X obj 45 88 noteout 1;
#X obj 428 101 random 500;
#X obj 260 101 random 88;
#X obj 260 124 + 21;
#X text 120 200 borax :: analyse incoming midi notes;
#X text 363 13 <-- click to play random music;
#X obj 40 125 notein 1;
#X text 186 300 delta time value - time between note-ons;
#X text 160 350 duration value - time between note-on and note-off
;
#X text 79 502 note-on count;
#X text 141 374 duration count;
#X text 164 326 delta time count;
#X obj 336 101 random 1000;
#X text 153 228 <-- reset :: sets counters and clocks to zero and sends
;
#X text 258 243 note-off for all notes currently playing;
#X text 137 273 <--- zeroes only added to make the object larger;
#X connect 0 0 10 2;
#X connect 10 0 3 0;
#X connect 10 1 5 0;
#X connect 10 2 2 0;
#X connect 10 3 4 0;
#X connect 10 4 7 0;
#X connect 10 5 9 0;
#X connect 10 6 6 0;
#X connect 10 7 8 0;
#X connect 10 8 1 0;
#X connect 14 0 10 0;
#X connect 14 0 31 0;
#X connect 14 1 10 1;
#X connect 14 1 31 1;
#X connect 15 0 24 0;
#X connect 15 0 32 0;
#X connect 15 0 33 0;
#X connect 15 0 43 0;
#X connect 16 0 17 0;
#X connect 18 0 15 1;
#X connect 20 0 14 0;
#X connect 21 0 14 1;
#X connect 22 0 15 0;
#X connect 23 0 15 0;
#X connect 24 0 25 0;
#X connect 25 0 26 0;
#X connect 27 0 14 2;
#X connect 29 0 28 0;
#X connect 32 0 16 0;
#X connect 33 0 34 0;
#X connect 34 0 19 0;
#X connect 37 0 10 0;
#X connect 37 1 10 1;
#X connect 43 0 29 0;
--- NEW FILE: help-score.pd ---
#N canvas 246 86 629 516 12;
#X floatatom 30 301 5 0 0;
#X obj 30 12 notein;
#X obj 193 202 bng 20 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
-1;
#X msg 95 93 start;
#X msg 104 118 stop;
#X text 217 203 reset;
#X text 145 92 start / stop score following;
#X msg 111 146 start 4;
#X text 176 146 start skipping first 4 notes;
#X obj 193 286 bng 20 250 50 0 empty empty empty 0 -6 0 8 -262144 -258699
-1;
#X text 217 287 error;
#X text 148 24 score :: score follower that tries to match incoming
;
#X text 221 41 MIDI data to a score stored in an array;
#X text 219 57 outputs the index number of current position;
#X obj 23 423 loadbang;
#N canvas 0 0 450 300 graph2 0;
#X array sco_array 25 float 1;
#A 0 60 61 62 63 64 65 66 67 68 69 70 71 72 71 70 69 68 67 66 65 64
63 62 61 60;
#X coords 0 127 24 0 200 140 1;
#X restore 402 361 graph;
#X obj 30 235 score sco_array 2 300;
#X msg 130 173 set sco_array;
#X msg 23 449 \; sco_array resize 25 \; sco_array read examplescore.txt
\;;
#X text 250 174 set to array that contains the score;
#X text 88 303 position on score;
#X text 86 322 (x index of array);
#X obj 30 356 tabread sco_array;
#X floatatom 30 387 5 0 0;
#X text 86 388 note from score;
#X text 291 255 array: name of array containing score;
#X text 235 234 USAGE: score <array> <skipitems> <skiptime>;
#X text 292 272 skipitems: max. number of notes to skip;
#X text 292 289 skip time: max. time [ms] to rewind;
#X text 378 307 input data;
#X connect 0 0 22 0;
#X connect 1 0 16 0;
#X connect 1 1 16 1;
#X connect 2 0 16 2;
#X connect 3 0 16 0;
#X connect 4 0 16 0;
#X connect 7 0 16 0;
#X connect 14 0 18 0;
#X connect 16 0 0 0;
#X connect 16 1 9 0;
#X connect 17 0 16 0;
#X connect 22 0 23 0;
--- NEW FILE: help-iso.pd ---
#N canvas 438 64 464 535 12;
#X obj 16 407 iso;
#X floatatom 16 434 5 0 0;
#X floatatom 69 434 10 0 0;
#X msg 72 156 bang;
#X msg 96 207 stop;
#X msg 106 233 pause;
#X msg 117 259 resume;
#X msg 128 285 loop;
#X msg 139 311 unloop;
#X text 214 100 list of pitches;
#X text 273 129 list of attacks [ms];
#X text 170 284 turn loopin back on;
#X text 198 309 turn looping off;
#X obj 16 460 makenote 0 100;
#X obj 16 487 noteout;
#X text 112 156 start from beginning;
#X text 149 183 start at item specyfied;
#X text 281 145 (inter-note onsets);
#X text 88 45 ported to Pd by Olaf Matthes;
#X text 216 337 global time multiplier;
#X text 163 435 duration in ms;
#X msg 152 337 hook 2;
#X msg 161 368 duty 1.5;
#X text 234 369 duration multiplier;
#X obj 16 69 loadbang;
#X msg 82 182 start 4;
#X text 251 350 (speed adjustment);
#X text 237 389 duty < 1 - staccato;
#X text 237 404 duty > 1 - legato;
#X text 169 198 (item count starts with 0);
#X text 88 26 written for Max by Charlie Baker;
#X text 31 6 iso :: queues up lists of pitches and attack points;
#X msg 16 100 60 61 62 66 67 68 69 70;
#X msg 35 128 240 10 500 375 15 15 375 500;
#X connect 0 0 1 0;
#X connect 0 1 2 0;
#X connect 1 0 13 0;
#X connect 2 0 13 1;
#X connect 3 0 0 0;
#X connect 4 0 0 0;
#X connect 5 0 0 0;
#X connect 6 0 0 0;
#X connect 7 0 0 0;
#X connect 8 0 0 0;
#X connect 13 0 14 0;
#X connect 13 1 14 1;
#X connect 21 0 0 0;
#X connect 22 0 0 0;
#X connect 24 0 32 0;
#X connect 24 0 33 0;
#X connect 25 0 0 0;
#X connect 32 0 0 0;
#X connect 33 0 0 1;
--- NEW FILE: help-speedlim.pd ---
#N canvas 445 253 464 314 12;
#X floatatom 38 54 5 0 0;
#X floatatom 18 264 5 0 0;
#X obj 38 141 speedlim 500;
#X text 126 18 speedlim :: lets information through;
#X text 222 37 only every N milliseconds;
#X text 152 171 creation argument = time in ms;
#X floatatom 129 116 5 0 0;
#X text 184 116 time between outputs in ms;
#X msg 49 82 bang;
#X obj 121 207 bng 20 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
-1;
#X obj 121 236 timer;
#X floatatom 121 262 5 0 0;
#X text 175 262 this should never be less than;
#X text 175 280 the creation argument of speedlim;
#X obj 18 194 route f;
#X obj 47 236 print;
#X msg 95 82 this is speedlim;
#X connect 0 0 2 0;
#X connect 2 0 9 0;
#X connect 2 0 14 0;
#X connect 6 0 2 1;
#X connect 8 0 2 0;
#X connect 9 0 10 1;
#X connect 9 0 10 0;
#X connect 10 0 11 0;
#X connect 14 0 1 0;
#X connect 14 1 15 0;
#X connect 16 0 2 0;
--- NEW FILE: help-netdist.pd ---
#N canvas 374 142 458 370 12;
#X obj 23 299 netdist;
#X obj 275 249 netreceive 3000;
#X floatatom 275 275 5 0 0;
#X floatatom 390 275 5 0 0;
#X msg 23 64 connect localhost 3000;
#X floatatom 276 328 5 0 0;
#X floatatom 391 328 5 0 0;
#X obj 276 302 netreceive 3001;
#X msg 67 120 disconnect localhost 3000;
#X msg 42 93 connect localhost 3001;
#X msg 88 147 disconnect localhost 3001;
#X msg 102 177 print;
#X msg 113 203 clear;
#X floatatom 23 326 5 0 0;
#X msg 120 232 send 23;
#X msg 146 259 send 17.3;
#X text 151 178 print list of connections;
#X text 164 202 disconnect all;
#X text 189 232 send values;
#X text 213 64 add connection to list;
#X text 278 119 remove connection;
#X text 33 8 netdist :: distribute data to several netreceive;
#X text 122 24 written by Olaf Matthes;
#X connect 0 0 13 0;
#X connect 1 0 2 0;
#X connect 1 1 3 0;
#X connect 4 0 0 0;
#X connect 7 0 5 0;
#X connect 7 1 6 0;
#X connect 8 0 0 0;
#X connect 9 0 0 0;
#X connect 10 0 0 0;
#X connect 11 0 0 0;
#X connect 12 0 0 0;
#X connect 14 0 0 0;
#X connect 15 0 0 0;
--- NEW FILE: help-step.pd ---
#N canvas 417 206 533 314 12;
#X floatatom 33 229 5 0 0;
#X text 72 7 step :: output sequence of numbers (similar to 'line')
;
#X text 138 25 written by Olaf Matthes (olaf.matthes(a)gmx.de);
#X text 222 250 stepsize :: step between two numbers;
#X msg 33 76 23 6000 2;
#X msg 62 119 230;
#X obj 101 282 line;
#X text 98 117 send a single number to jump;
#X text 121 77 send a triplet to step to a new value;
#X text 22 282 see also:;
#X msg 80 146 stop;
#X text 127 147 "stop" message to stop output;
#X text 121 92 <new value> <time> <step>;
#X text 123 196 step <value> <stepsize>;
#X text 221 234 value :: value to start with;
#X obj 33 195 step 100 3;
#X connect 4 0 15 0;
#X connect 5 0 15 0;
#X connect 10 0 15 0;
#X connect 15 0 0 0;
--- NEW FILE: help-unroute.pd ---
#N canvas 413 157 539 407 12;
#X obj 64 343 print;
#X msg 64 89 1 \$1;
#X msg 112 110 2 \$1;
#X msg 163 116 3 \$1;
#X floatatom 64 62 5 0 0;
#X floatatom 112 85 5 0 0;
#X floatatom 163 91 5 0 0;
#X obj 64 232 route 1 2 3 4;
#X obj 64 314 unroute one 2 three 4;
#X text 52 13 unroute :: merges all inputs into one output;
#X text 138 30 and prepends an identifier;
#X text 138 47 written by Olaf Matthes <olaf.matthes(a)gmx.de>;
#X msg 194 170 4 this came through 4;
#X msg 209 196 3 drei;
#X msg 174 146 4 25 467 23.6;
#X connect 1 0 7 0;
#X connect 2 0 7 0;
#X connect 3 0 7 0;
#X connect 4 0 1 0;
#X connect 5 0 2 0;
#X connect 6 0 3 0;
#X connect 7 0 8 0;
#X connect 7 1 8 1;
#X connect 7 2 8 2;
#X connect 7 3 8 3;
#X connect 8 0 0 0;
#X connect 12 0 7 0;
#X connect 13 0 7 0;
#X connect 14 0 7 0;
--- NEW FILE: help-subst.pd ---
#N canvas 249 69 784 504 12;
#X obj 19 346 print;
#X msg 143 272 bang;
#X text 190 180 minimum order of substitution;
#X msg 122 181 order 2;
#X msg 19 118 72 68 67 64 69 71 77 75 70 73 74 78;
#X floatatom 98 347 5 0 0;
#X text 151 348 length of row;
#X msg 138 241 intervall 4;
#X obj 541 228 noteout;
#N canvas 0 0 450 300 graph1 0;
#X array array01 100 float 0;
#X coords 0 127 99 0 200 140 1;
#X restore 564 321 graph;
#X obj 506 43 tgl 20 0 empty empty empty 0 -6 0 8 -262144 -1 -1 0 1
;
#X text 537 42 << switch playback on/off;
#X obj 506 93 int 0;
#X obj 558 93 + 1;
#X text 27 19 subst :: self-similar substitution / diminuition of rows
;
#X text 87 307 [subst <order>];
#X obj 506 146 sel 0;
#X obj 98 374 s length;
#X obj 541 120 r length;
#X obj 541 173 tabread array01;
#X msg 506 173 0;
#X obj 506 67 metro 250;
#X obj 541 201 makenote 100 250;
#X obj 19 306 subst 2;
#X text 99 35 play it and you'll never get a note repetition;
#X msg 125 212 set array01;
#N canvas 0 0 450 300 graph1 0;
#X array array00 12 float 1;
#A 0 72 68 67 64 69 71 77 75 70 73 74 78;
#X coords 0 127 11 0 200 140 1;
#X restore 291 321 graph;
#X msg 118 146 load array00;
#X text 222 211 set array for processing and output;
#X obj 21 417 subst array00 3;
#X text 295 464 THE INPUT;
#X text 574 464 THE OUTPUT;
#X text 315 119 send it a list;
#X text 226 147 or load values from array;
#X text 18 444 use creation arguments to set;
#X text 18 458 name of output array and order;
#X text 17 472 of substitution;
#X text 99 55 written by Olaf Matthes <olaf.matthes(a)gmx.de>;
#X text 244 241 substitute the Nth interval;
#X text 187 272 substitute now \, choose interval by chance;
#X connect 1 0 23 0;
#X connect 3 0 23 0;
#X connect 4 0 23 0;
#X connect 5 0 17 0;
#X connect 7 0 23 0;
#X connect 10 0 21 0;
#X connect 12 0 13 0;
#X connect 12 0 16 0;
#X connect 13 0 12 1;
#X connect 16 0 20 0;
#X connect 16 1 19 0;
#X connect 18 0 16 1;
#X connect 19 0 22 0;
#X connect 20 0 12 1;
#X connect 20 0 1 0;
#X connect 21 0 12 0;
#X connect 22 0 8 0;
#X connect 22 1 8 1;
#X connect 23 0 0 0;
#X connect 23 1 5 0;
#X connect 25 0 23 0;
#X connect 27 0 23 0;
--- NEW FILE: help-velocity.pd ---
#N canvas 239 183 454 304 12;
#X text 30 16 velocity :: get velocity of digits per second;
#X obj 50 137 velocity;
#X floatatom 50 72 5 0 0;
#X floatatom 50 187 8 0 0;
#X text 150 77 sending a float every second would;
#X text 151 95 result in a velocity of 1 \, higher;
#X text 151 114 rates produce higher velocities;
#X msg 65 102 bang;
#X text 151 148 originally written for Max by;
#X text 151 164 Trond Lossius \, BEK;
#X connect 1 0 3 0;
#X connect 2 0 1 0;
#X connect 7 0 1 0;
--- NEW FILE: help-dist.pd ---
#N canvas 450 84 473 453 12;
#X text 33 10 dist :: send data to a list of receive objects;
#X obj 34 364 dist;
#X msg 85 127 connect bla;
#X msg 103 154 connect foo;
#X msg 131 209 disconnect bla;
#X msg 145 237 disconnect foo;
#X msg 158 295 clear;
#X obj 200 374 receive bla;
#X obj 306 374 receive foo;
#X obj 200 400 print bla;
#X obj 306 400 print foo;
#X floatatom 34 69 5 0 0;
#X msg 170 328 print;
#X msg 56 98 send anything 1 2 dog;
#X obj 34 397 d bla foo;
#X msg 122 180 connect dog cat;
#X msg 159 265 disconnect cat dog;
#X text 210 295 empty receiver list;
#X text 218 328 print list of receive names;
#X text 190 126 add 'bla' to list of receivers;
#X text 253 209 remove 'bla' from list;
#X text 238 99 send anything you want;
#X text 97 28 written by Olaf Matthes <olaf.matthes(a)gmx.de>;
#X connect 2 0 1 0;
#X connect 3 0 1 0;
#X connect 4 0 1 0;
#X connect 5 0 1 0;
#X connect 6 0 1 0;
#X connect 7 0 9 0;
#X connect 8 0 10 0;
#X connect 11 0 1 0;
#X connect 12 0 1 0;
#X connect 13 0 1 0;
#X connect 15 0 1 0;
#X connect 16 0 1 0;
--- NEW FILE: help-weibull.pd ---
#N canvas 438 222 487 308 12;
#X obj 70 95 bng 20 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
-1;
#X floatatom 70 192 5 0 0;
#X floatatom 151 94 5 0 0;
#X floatatom 233 116 5 0 0;
#X obj 70 140 weibull 0.78 1.3;
#X text 286 117 t;
#X text 204 95 s;
#X text 123 247 s and t must be greater than zero;
#X text 39 21 weibull :: Weibull distributed random numbers;
#X connect 0 0 4 0;
#X connect 2 0 4 1;
#X connect 3 0 4 2;
#X connect 4 0 1 0;
--- NEW FILE: help-listfunnel.pd ---
#N canvas 280 185 452 302 12;
#X obj 47 160 listfunnel;
#X floatatom 47 89 5 0 0;
#X obj 47 219 unpack f f;
#X floatatom 47 244 5 0 0;
#X floatatom 122 246 5 0 0;
#X obj 61 194 print listfunnel;
#X msg 73 114 17.3 23 147 11;
#X text 37 23 listfunnel :: send values out as a list with;
#X text 149 38 source index;
#X text 149 55 based on code found on the web;
#X msg 210 113 99 \$1 12;
#X floatatom 210 86 5 0 0;
#X connect 0 0 2 0;
#X connect 0 0 5 0;
#X connect 1 0 0 0;
#X connect 2 0 3 0;
#X connect 2 1 4 0;
#X connect 6 0 0 0;
#X connect 10 0 0 0;
#X connect 11 0 10 0;
--- NEW FILE: help-divmod.pd ---
#N canvas 328 264 464 316 12;
#X floatatom 54 239 5 0 0;
#X floatatom 54 127 5 0 0;
#X floatatom 129 127 5 0 0;
#X obj 54 172 divmod 8 6;
#X text 146 170 use creation arguments to set initial;
#X text 146 186 values for inlets;
#X msg 23 83 bang;
#X text 69 82 calculate and output result now;
#X floatatom 129 219 5 0 0;
#X text 182 222 modulo;
#X text 106 242 result of division;
#X text 186 127 takes int's only!;
#X text 12 19 divmod :: calculate division and modulo;
#X text 92 35 outputs results even when right inlet changes;
#X connect 1 0 3 0;
#X connect 2 0 3 1;
#X connect 3 0 0 0;
#X connect 3 1 8 0;
#X connect 6 0 3 0;
--- NEW FILE: help-poisson.pd ---
#N canvas 438 222 487 308 12;
#X obj 70 95 bng 20 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
-1;
#X floatatom 70 192 5 0 0;
#X floatatom 193 112 5 0 0;
#X text 39 21 poisson :: Poisson distributed random numbers;
#X obj 70 145 poisson 2.2;
#X text 246 113 lambda - value that is most;
#X text 317 132 likely to appear;
#X connect 0 0 4 0;
#X connect 2 0 4 1;
#X connect 4 0 1 0;
--- NEW FILE: help-beat.pd ---
#N canvas 294 98 628 562 12;
#X floatatom 20 503 8 0 0;
#X obj 20 66 notein;
#X obj 183 376 makenote 100 250;
#X floatatom 41 477 5 0 0;
#X text 43 13 beat :: beat tracker;
#X text 97 505 beats per minute;
#X msg 71 224 reset;
#X obj 183 219 tgl 20 0 empty empty empty 0 -6 0 8 -262144 -1 -1 1
1;
#X msg 183 346 60;
#X msg 53 108 print;
#X obj 63 446 bng 20 250 50 0 empty empty empty 0 -6 0 8 -262144 -258699
-1;
#X text 93 447 'on beat';
#X text 96 479 milliseconds;
#X msg 303 336 400;
#X obj 319 299 + 0;
#X text 411 245 <-- adding some jitter;
#X obj 183 271 random 4;
#X obj 183 298 select 0 1 2 3;
#X text 211 218 <-- click here to play random rhythm;
#X obj 338 243 random 3;
#X obj 338 270 - 1;
#X obj 20 414 beat 4;
#X text 88 415 creation: beat <band percentage>;
#X text 349 456 certain percentage in which;
#X text 350 472 the beats have to lie;
#X msg 262 337 200;
#X msg 222 336 100;
#X obj 183 245 metro 100;
#X text 106 108 print internal data (toggle on/off);
#X text 106 136 prints out: time between current and last event \,
the five best-fitting theories (with likelyhood in brackets) \, the
time of arrival of current event (R) and the expected time of arrival
(E) of the next event;
#X text 213 439 band percentage: creates a critical time band of a
;
#X connect 1 0 21 0;
#X connect 1 1 21 1;
#X connect 2 0 21 0;
#X connect 2 1 21 1;
#X connect 6 0 21 0;
#X connect 7 0 27 0;
#X connect 8 0 2 0;
#X connect 9 0 21 0;
#X connect 13 0 14 0;
#X connect 14 0 27 1;
#X connect 16 0 17 0;
#X connect 17 0 8 0;
#X connect 17 0 26 0;
#X connect 17 1 8 0;
#X connect 17 1 25 0;
#X connect 17 2 13 0;
#X connect 17 2 8 0;
#X connect 17 3 8 0;
#X connect 17 3 13 0;
#X connect 19 0 20 0;
#X connect 20 0 14 1;
#X connect 21 0 0 0;
#X connect 21 1 3 0;
#X connect 21 2 10 0;
#X connect 25 0 14 0;
#X connect 26 0 14 0;
#X connect 27 0 16 0;
#X connect 27 0 19 0;
--- NEW FILE: help-arraycopy.pd ---
#N canvas 140 43 934 584 12;
#N canvas 0 0 450 300 graph1 0;
#X array array1 20 float 1;
#A 0 0 0 0.342857 0.542857 0.6 -0.442857 -0.485714 0.0142858 -0.428571
-0.114286 0.0857143 -0.2 -0.214285 0.314285 -0.157143 -0.314285 -0.142857
-0.0428571 0.114286 -0.685713;
#X coords 0 1 19 -1 200 140 1;
#X restore 680 27 graph;
#N canvas 0 0 450 300 graph2 0;
#X array array2 20 float 1;
#A 0 -0.214286 -0.171429 0.1 0.614286 0.757143 0.757143 0.542857 0.2
-0.0285714 -0.271429 -0.414286 -0.514286 -0.528571 -0.485714 -0.371429
-0.157143 0.214286 0.557143 0.714286 0.757143;
#X coords 0 1 19 -1 200 140 1;
#X restore 681 196 graph;
#N canvas 0 0 450 300 graph3 0;
#X array array3 20 float 1;
#A 0 1.86265e-009 1.86265e-009 1.86265e-009 1.86265e-009 1.86265e-009
-0.0142857 -0.0142857 -0.0142857 -0.0142857 -0.0142857 -0.0142857 -0.0142857
-0.0142857 -0.0285714 -0.0285714 -0.0285714 -0.0285714 -0.0142857 -0.0142857
-0.0142857;
#X coords 0 1 19 -1 200 140 1;
#X restore 680 371 graph;
#X obj 22 500 arraycopy array3;
#X text 339 402 set the destination array;
#X text 41 1 arraycopy :: copy data from one array to another;
#X text 146 22 written by Olaf Matthes <olaf.matthes(a)gmx.de>;
#X msg 22 109 copy array1;
#X msg 43 139 copy array1 10 15;
#X text 131 109 copy the whole array;
#X text 200 140 copy from value 10 to 15;
#X msg 60 169 copy array1 10 +5;
#X text 217 170 copy from value 10 the next 5 values;
#X msg 85 359 print \$1;
#X obj 85 333 tgl 20 0 empty empty empty 0 -6 0 8 -262144 -1 -1 0 1
;
#X text 116 334 switch console printout on/off;
#X text 281 202 copy from value 10 to 15;
#X msg 73 201 copy array1 10 15 array2;
#X text 280 222 into array2 (starting at 0);
#X text 322 251 copy from value 10 to 15;
#X text 321 271 into array2 starting at 4;
#X msg 92 250 copy array1 10 15 array2 4;
#X msg 368 454 array3;
#X msg 86 414 bang;
#X text 137 412 perform last copy;
#X text 137 429 operation again;
#X text 20 537 creation argument: initial destination array to copy
data to;
#X obj 200 502 symbol;
#X msg 339 428 array2;
#X connect 7 0 3 0;
#X connect 8 0 3 0;
#X connect 11 0 3 0;
#X connect 13 0 3 0;
#X connect 14 0 13 0;
#X connect 17 0 3 0;
#X connect 21 0 3 0;
#X connect 22 0 27 0;
#X connect 23 0 3 0;
#X connect 27 0 3 1;
#X connect 28 0 27 0;
--- NEW FILE: help-edge.pd ---
#N canvas 258 208 452 302 12;
#X obj 100 154 edge;
#X obj 100 215 bng 20 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
-1;
#X obj 127 186 bng 20 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
-1;
#X text 156 186 falling edge detected;
#X text 128 216 rising edge detected;
#X text 31 16 edge :: detect rising or falling edge in floats;
#X floatatom 126 111 5 0 0;
#X obj 100 79 tgl 20 0 empty empty empty 0 -6 0 8 -262144 -1 -1 0 1
;
#X text 94 35 written by <olaf.matthes(a)gmx.de>;
#X connect 0 0 1 0;
#X connect 0 1 2 0;
#X connect 6 0 0 0;
#X connect 7 0 0 0;
--- NEW FILE: help-gestalt.pd ---
#N canvas 323 155 599 396 12;
#X text 137 8 gestalt :: gestalt detection for monophonic melodies
;
#X floatatom 58 332 5 0 0;
#X obj 58 176 makenote 100 100;
#X obj 58 53 tgl 20 0 empty empty empty 0 -6 0 8 -262144 -1 -1 1 1
;
#X obj 58 76 metro 100;
#X obj 58 100 random 24;
#X obj 58 124 + 60;
#X obj 58 278 gestalt 100;
#X obj 142 100 random 24;
#X obj 142 124 select 0;
#X msg 201 146 100;
#X msg 142 146 400;
#X floatatom 68 154 5 0 0;
#X text 160 282 CREATION ARGUMENT: reference time;
#X obj 219 220 beat;
#X floatatom 232 245 5 0 0;
#X text 87 54 click to play random melody;
#X text 112 350 one could use 'tilt' to detect abrupt changes that
;
#X text 112 367 indicate the start of a new segment;
#X text 111 332 the higher the output the more the gestalt changes
\;;
#X text 161 298 i.e. time in ms expected to be the duration of the
;
#X text 161 314 shortest note (also setable via rightmost inlet);
#X text 281 200 use 'beat' (maxlib) to get the real;
#X text 281 217 reference time from input \, especially;
#X text 282 234 when using;
#X obj 372 235 notein;
#X text 225 26 written by <olaf.matthes(a)gmx.de>;
#X connect 2 0 7 0;
#X connect 2 0 14 0;
#X connect 2 1 7 1;
#X connect 2 1 14 1;
#X connect 3 0 4 0;
#X connect 4 0 5 0;
#X connect 4 0 8 0;
#X connect 5 0 6 0;
#X connect 6 0 2 0;
#X connect 6 0 12 0;
#X connect 7 0 1 0;
#X connect 8 0 9 0;
#X connect 9 0 11 0;
#X connect 9 1 10 0;
#X connect 10 0 2 2;
#X connect 11 0 2 2;
#X connect 14 1 15 0;
#X connect 14 1 7 2;
--- NEW FILE: help-triang.pd ---
#N canvas 370 195 483 304 12;
#X obj 70 95 bng 20 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
-1;
#X floatatom 70 192 5 0 0;
#X obj 70 141 triang;
#X text 19 20 triang :: triangularly distributed random numbers
;
#X connect 0 0 2 0;
#X connect 2 0 1 0;
--- NEW FILE: help-pulse.pd ---
#N canvas 499 150 464 314 12;
#X obj 23 223 pulse 120 1 4 0;
#X floatatom 23 265 5 0 0;
#X obj 138 265 bng 20 250 50 0 empty empty empty 0 -6 0 8 -262144 -258699
-1;
#X msg 23 23 0;
#X msg 48 80 1;
#X floatatom 51 122 5 0 0;
#X floatatom 138 197 5 0 0;
#X floatatom 109 172 5 0 0;
#X floatatom 80 147 5 0 0;
#X msg 39 53 bang;
#X text 55 23 stop;
#X obj 313 18 metro;
#X text 80 79 start;
#X text 242 44 originally written by;
#X text 240 62 James McCartney for Max;
#X text 74 267 count;
#X text 168 18 pulse :: a better;
#X text 104 123 quarter notes per minute;
#X text 190 199 number of beats to play;
#X text 189 214 before turning off;
#X text 77 54 toggles on/off;
#X text 131 148 interval at which a bang is output;
#X text 160 174 notes to count (default = quarter);
#X text 166 264 pulse turned off automagically;
#X connect 0 0 1 0;
#X connect 0 1 2 0;
#X connect 3 0 0 0;
#X connect 4 0 0 0;
#X connect 5 0 0 1;
#X connect 6 0 0 4;
#X connect 7 0 0 3;
#X connect 8 0 0 2;
#X connect 9 0 0 0;
--- NEW FILE: help-cauchy.pd ---
#N canvas 438 222 487 308 12;
#X obj 70 95 bng 20 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
-1;
#X floatatom 70 192 5 0 0;
#X floatatom 185 103 5 0 0;
#X obj 70 140 cauchy 0.5;
#X text 238 104 alpha - governs spread;
#X text 39 21 cauchy :: Cauchy distributed random numbers;
#X connect 0 0 3 0;
#X connect 2 0 3 1;
#X connect 3 0 1 0;
--- NEW FILE: help-scale.pd ---
#N canvas 381 126 552 355 12;
#X floatatom 27 277 8 0 0;
#X floatatom 27 73 5 0 0;
#X text 213 48 written by <olaf.matthes(a)gmx.de>;
#X text 37 306 creation:;
#X text 141 11 scale :: scale input from a certain input range;
#X text 212 29 to lie between output boundaries;
#X floatatom 56 131 5 0 0;
#X floatatom 85 152 5 0 0;
#X floatatom 115 173 5 0 0;
#X floatatom 144 194 5 0 0;
#X text 84 71 input value;
#X text 106 278 scaled output value;
#X text 111 130 in low;
#X text 137 151 in high;
#X text 171 172 out low;
#X text 200 194 out high;
#X text 57 104 creation arguments can be changed dynamically:;
#X text 53 323 scale <in low> <in high> <out low> <out high> <log coeff>
;
#X obj 27 249 scale 0 9 100 255 0;
#X floatatom 174 220 5 0 0;
#X text 227 219 log coefficient;
#X text 265 237 0 = linear 1 = log;
#X connect 1 0 18 0;
#X connect 6 0 18 1;
#X connect 7 0 18 2;
#X connect 8 0 18 3;
#X connect 9 0 18 4;
#X connect 18 0 0 0;
#X connect 19 0 18 5;
--- NEW FILE: help-gauss.pd ---
#N canvas 438 222 487 308 12;
#X obj 70 95 bng 20 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
-1;
#X floatatom 70 192 5 0 0;
#X floatatom 123 91 5 0 0;
#X obj 70 140 gauss 1 0;
#X floatatom 177 113 5 0 0;
#X text 39 21 gauss :: Gauss distributed random numbers;
#X text 176 92 sigma - standard deviation;
#X text 230 114 mu - mean;
#X connect 0 0 3 0;
#X connect 2 0 3 1;
#X connect 3 0 1 0;
#X connect 4 0 3 2;
--- NEW FILE: help-listfifo.pd ---
#N canvas 476 153 456 307 12;
#X floatatom 104 231 5 0 0 0 - - -;
#X msg 38 46 bang;
#X text 146 152 fifo <size>;
#X obj 38 152 listfifo 10;
#X text 42 14 listfifo :: first in first out buffer for lists;
#X obj 104 187 unpack f f;
#X floatatom 179 230 5 0 0 0 - - -;
#X obj 38 263 print listfifo_output;
#X text 204 185 output of listfifo;
#X msg 66 76 17.3 23;
#X obj 166 101 pack f f;
#X floatatom 166 70 5 0 0 0 - - -;
#X floatatom 225 70 5 0 0 0 - - -;
#X msg 84 125 \$1 \$2;
#X text 83 46 hit to get next number out of the fifo;
#X connect 1 0 3 0;
#X connect 3 0 5 0;
#X connect 3 0 7 0;
#X connect 5 0 0 0;
#X connect 5 1 6 0;
#X connect 9 0 3 0;
#X connect 10 0 13 0;
#X connect 11 0 10 0;
#X connect 12 0 10 1;
#X connect 13 0 3 0;
--- NEW FILE: help-minus.pd ---
#N canvas 328 264 464 316 12;
#X floatatom 54 217 5 0 0;
#X floatatom 54 127 5 0 0;
#X floatatom 107 127 5 0 0;
#X text 39 20 minus :: like '-' but calculates result;
#X text 133 204 use creation arguments to set initial;
#X text 133 220 values for inlets;
#X msg 23 83 bang;
#X text 69 82 calculate and output result now;
#X obj 54 172 minus 8 6 4;
#X floatatom 161 127 5 0 0;
#X text 120 38 when leftmost or second inlet is changed;
#X connect 1 0 8 0;
#X connect 2 0 8 1;
#X connect 6 0 8 0;
#X connect 8 0 0 0;
#X connect 9 0 8 2;
--- NEW FILE: help-remote.pd ---
#N canvas 472 309 567 308 12;
#X text 9 9 remote :: send data to any receive object;
#X obj 32 224 remote;
#X obj 216 222 receive bla;
#X obj 321 222 receive foo;
#X obj 216 250 print bla;
#X obj 321 250 print foo;
#X msg 32 104 bla 17.3 23;
#X msg 76 183 foo 13 \, bla 4;
#X text 148 75 use message: <name> <data>;
#X text 253 91 with data of any type;
#X text 89 26 written by Olaf Matthes <olaf.matthes(a)gmx.de>;
#X msg 61 147 foo five is 2 more than 3;
#X msg 294 146 \; bla 17.3 23;
#X text 296 168 this does the same...;
#X connect 2 0 4 0;
#X connect 3 0 5 0;
#X connect 6 0 1 0;
#X connect 7 0 1 0;
#X connect 11 0 1 0;
--- NEW FILE: help-allow.pd ---
#N canvas 358 305 554 308 12;
#X text 24 17 allow :: lets only 'allowed' floats or symbols through
;
#X text 97 34 written by Olaf Matthes <olaf.matthes(a)gmx.de>;
#X msg 125 65 cat;
#X msg 147 97 dog;
#X msg 157 126 bird;
#X floatatom 82 269 5 0 0 0 - - -;
#X symbolatom 151 246 10 0 0 0 - - -;
#X obj 114 156 symbol \$1;
#X floatatom 40 81 5 0 0 0 - - -;
#X obj 82 217 route float symbol;
#X obj 82 189 allow 17 cat dog 23;
#X connect 2 0 7 0;
#X connect 3 0 7 0;
#X connect 4 0 7 0;
#X connect 7 0 10 0;
#X connect 8 0 10 0;
#X connect 9 0 5 0;
#X connect 9 1 6 0;
#X connect 10 0 9 0;
--- NEW FILE: help-temperature.pd ---
#N canvas 214 144 454 304 12;
#X obj 45 139 temperature 500;
#X floatatom 45 193 5 0 0;
#X floatatom 45 91 5 0 0;
#X text 11 10 temperature :: oputput number of input changes in N ms
;
#X text 132 27 written by <olaf.matthes(a)gmx.de>;
#X floatatom 160 104 5 0 0;
#X text 219 103 set new time interval;
#X text 104 192 number of changes (i.e. the 'temperature');
#X text 104 209 of the input during one time interval;
#X msg 68 112 foo;
#X connect 0 0 1 0;
#X connect 2 0 0 0;
#X connect 5 0 0 1;
#X connect 9 0 0 0;
--- NEW FILE: help-chord.pd ---
#N canvas 291 216 458 308 12;
#X floatatom 15 276 5 0 0;
#X symbolatom 44 212 48 0 0;
#X floatatom 74 149 5 0 0;
#X floatatom 131 149 5 0 0;
#X floatatom 189 149 5 0 0;
#X floatatom 248 149 5 0 0;
#X floatatom 59 182 5 0 0;
#X text 71 276 MIDI note number of bass note;
#X text 116 175 root position (0) \, 1st inversion (1);
#X text 115 188 or 2nd inversion (2);
#X floatatom 29 249 5 0 0;
#X text 84 251 class of bass note;
#X text 231 118 list of chord notes;
#X obj 15 51 notein;
#X obj 15 86 chord 59;
#X text 90 86 <-- notes higher than 59 get ignored;
#X text 15 9 chord :: tries to detect chords;
#X text 89 232 notes in chord : chord name;
#X text 89 26 written by Olaf Matthes <olaf.matthes(a)gmx.de>;
#X text 89 44 based on code by Rober Rowe;
#X obj 74 118 unpack f f f f f f;
#X floatatom 303 149 5 0 0;
#X floatatom 362 149 5 0 0;
#X connect 13 0 14 0;
#X connect 13 1 14 1;
#X connect 14 0 0 0;
#X connect 14 1 10 0;
#X connect 14 2 1 0;
#X connect 14 3 6 0;
#X connect 14 4 20 0;
#X connect 20 0 2 0;
#X connect 20 1 3 0;
#X connect 20 2 4 0;
#X connect 20 3 5 0;
#X connect 20 4 21 0;
#X connect 20 5 22 0;
--- NEW FILE: help-fifo.pd ---
#N canvas 356 196 452 302 12;
#X obj 38 176 fifo 10;
#X floatatom 38 231 5 0 0;
#X floatatom 61 132 5 0 0;
#X msg 38 98 bang;
#X text 83 98 hit to get next number;
#X text 111 176 fifo <size>;
#X text 92 233 output of fifo;
#X text 42 14 fifo :: first in first out buffer for floats;
#X text 105 32 written for Max by St. Rainstick;
#X connect 0 0 1 0;
#X connect 2 0 0 0;
#X connect 3 0 0 0;
--- NEW FILE: help-netrec.pd ---
#N canvas 315 121 600 364 12;
#X obj 49 189 netrec 3000;
#X obj 57 130 netsend;
#X msg 57 18 connect localhost 3000;
#X msg 78 44 disconnect localhost 3000;
#X floatatom 49 297 5 0 0;
#X floatatom 76 270 5 0 0;
#X floatatom 93 73 5 0 0;
#X msg 93 99 send \$1;
#X symbolatom 132 217 10 0 0;
#X text 224 217 IP address;
#X text 100 298 received data;
#X text 129 270 number of connections;
#X obj 295 128 netsend;
#X msg 295 16 connect localhost 3000;
#X msg 316 42 disconnect localhost 3000;
#X floatatom 331 71 5 0 0;
#X msg 331 97 send \$1;
#X msg 49 162 print;
#X floatatom 104 243 5 0 0;
#X text 162 247 socket number;
#X connect 0 0 4 0;
#X connect 0 1 5 0;
#X connect 0 2 18 0;
#X connect 0 3 8 0;
#X connect 2 0 1 0;
#X connect 3 0 1 0;
#X connect 6 0 7 0;
#X connect 7 0 1 0;
#X connect 13 0 12 0;
#X connect 14 0 12 0;
#X connect 15 0 16 0;
#X connect 16 0 12 0;
#X connect 17 0 0 0;
--- NEW FILE: help-linear.pd ---
#N canvas 206 71 452 302 12;
#X obj 70 140 linear;
#X obj 70 95 bng 20 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
-1;
#X floatatom 70 192 5 0 0;
#X text 23 20 linear :: linearly distributed random numbers;
#X connect 0 0 2 0;
#X connect 1 0 0 0;
--- NEW FILE: help-plus.pd ---
#N canvas 328 264 464 316 12;
#X floatatom 54 217 5 0 0;
#X floatatom 54 127 5 0 0;
#X floatatom 107 127 5 0 0;
#X text 133 204 use creation arguments to set initial;
#X text 133 220 values for inlets;
#X text 26 20 plus :: like '+' but calculates result;
#X msg 23 83 bang;
#X text 69 82 calculate and output result now;
#X obj 54 172 plus 8 6 2;
#X floatatom 161 127 5 0 0;
#X text 91 40 whenever leftmost or second inlet is changed;
#X connect 1 0 8 0;
#X connect 2 0 8 1;
#X connect 6 0 8 0;
#X connect 8 0 0 0;
#X connect 9 0 8 2;
--- NEW FILE: help-nchange.pd ---
#N canvas 271 238 519 310 12;
#X obj 30 213 nchange f;
#X obj 371 215 nchange l;
#X msg 367 144 bla foo dog;
#X msg 387 169 bla foo 23;
#X msg 348 121 bla foo dog 17;
#X obj 200 214 nchange s;
#X obj 200 185 symbol;
#X msg 200 126 dog;
#X msg 216 153 cat;
#X obj 162 15 change;
#X obj 371 253 print list;
#X obj 200 255 print symbol;
#X msg 30 152 0;
#X msg 43 180 1;
#X obj 30 257 print float;
#X text 100 34 written by Olaf Matthes <olaf.matthes(a)gmx.de>;
#X text 12 15 nchange :: a 'new';
#X text 22 77 The creation argument specifies whether nchange works
for floats \, symbols or lists.;
#X connect 0 0 14 0;
#X connect 1 0 10 0;
#X connect 2 0 1 0;
#X connect 3 0 1 0;
#X connect 4 0 1 0;
#X connect 5 0 11 0;
#X connect 6 0 5 0;
#X connect 7 0 6 0;
#X connect 8 0 6 0;
#X connect 12 0 0 0;
#X connect 13 0 0 0;
--- NEW FILE: help-tilt.pd ---
#N canvas 245 222 562 330 12;
#X floatatom 24 114 5 0 0;
#X obj 54 293 bng 20 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
-1;
#X floatatom 153 227 5 0 0;
#X text 210 228 interval;
#X text 39 20 tilt :: meassure 'tilt' of input;
#X text 226 186 trip point :: alert when exceeding;
#X text 339 203 this value;
#X text 215 128 low limit :: reset 'start tilt' in case;
#X text 319 143 value is below this for a;
#X text 319 160 longer time;
#X text 184 80 high limit :: ignore chnages higher than this;
#X text 163 56 tilt :: maximum value change within one interval;
#X obj 54 250 tilt 0.78 100;
#X msg 126 81 hi 230;
#X msg 139 127 low 17.3;
#X msg 139 186 trip 173;
#X msg 100 55 tilt 25;
#X connect 0 0 12 0;
#X connect 2 0 12 1;
#X connect 12 0 1 0;
#X connect 13 0 12 0;
#X connect 14 0 12 0;
#X connect 15 0 12 0;
#X connect 16 0 12 0;
--- NEW FILE: help-nroute.pd ---
#N canvas 252 37 630 380 12;
#X floatatom 116 199 5 0 0;
#X obj 41 290 print matched;
#X obj 116 256 print failed;
#X msg 78 151 8;
#X obj 41 226 nroute 8 2;
#X msg 41 77 0 8 15;
#X msg 56 105 17 3 45;
#X msg 116 153 3;
#X text 170 197 position to match;
#X floatatom 427 204 5 0 0;
#X obj 336 293 print matched;
#X obj 427 259 print failed;
#X obj 336 229 nroute fly 2;
#X msg 381 178 go;
#X msg 417 178 walk;
#X msg 336 80 swifts fly high;
#X msg 351 108 dogs walk slow;
#X msg 363 141 please go go;
#X text 153 152 what to match;
#X text 54 8 nroute :: route if Nth argument is matched;
#X text 135 24 written by Olaf Matthes <olaf.matthes(a)gmx.de>;
#X connect 0 0 4 2;
#X connect 3 0 4 1;
#X connect 4 0 1 0;
#X connect 4 1 2 0;
#X connect 5 0 4 0;
#X connect 6 0 4 0;
#X connect 7 0 4 1;
#X connect 9 0 12 2;
#X connect 12 0 10 0;
#X connect 12 1 11 0;
#X connect 13 0 12 1;
#X connect 14 0 12 1;
#X connect 15 0 12 0;
#X connect 16 0 12 0;
#X connect 17 0 12 0;
--- NEW FILE: help-mlife.pd ---
#N canvas 309 47 454 459 12;
#X floatatom 23 424 5 0 0;
#X floatatom 39 397 5 0 0;
#X floatatom 76 424 5 0 0;
#X floatatom 93 397 5 0 0;
#X floatatom 129 424 5 0 0;
#X floatatom 147 397 5 0 0;
#X floatatom 183 425 5 0 0;
#X floatatom 200 398 5 0 0;
#X msg 22 33 bang;
#X msg 69 123 randfill;
#X msg 84 150 fill 0;
#X msg 100 177 lo 2;
#X msg 108 204 hi 3;
#X msg 120 231 nset 3;
#X msg 161 312 display;
#X text 178 233 set neighbourhood;
#X text 151 205 set high;
#X text 146 176 set low;
#X text 151 150 fill cells with 0;
#X text 145 123 fill cells with random value;
#X text 226 312 display state of cells;
#X msg 35 72 1;
#X text 63 33 calculate next generation and output;
#X text 64 50 bangs on every cell that is alife;
#X text 68 72 calculate next generation and output;
#X text 68 89 1 if cell is alife \, 0 if dead;
#X text 227 329 in Pd console window;
#X text 142 355 mlife <number of cells> <view_start>;
#X text 189 370 <view_size> <closed>;
#X text 279 395 closed universe if;
#X text 279 409 <closed> = 1;
#X msg 134 258 randseed 4;
#X text 225 258 seed array with random no.;
#X text 225 284 seed array with a number;
#X msg 149 285 seed 1 4;
#X obj 23 356 mlife 8 1 8 0;
#X text 44 5 mlife :: a cellular automata object;
#X connect 8 0 35 0;
#X connect 9 0 35 0;
#X connect 10 0 35 0;
#X connect 11 0 35 0;
#X connect 12 0 35 0;
#X connect 13 0 35 0;
#X connect 14 0 35 0;
#X connect 21 0 35 0;
#X connect 31 0 35 0;
#X connect 34 0 35 0;
#X connect 35 0 0 0;
#X connect 35 1 1 0;
#X connect 35 2 2 0;
#X connect 35 3 3 0;
#X connect 35 4 4 0;
#X connect 35 5 5 0;
#X connect 35 6 6 0;
#X connect 35 7 7 0;
--- NEW FILE: help-match.pd ---
#N canvas 90 142 874 407 12;
#X obj 50 350 bng 24 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
-1;
#X msg 148 212 reset;
#X obj 50 95 random 5;
#X msg 50 5 0;
#X msg 65 32 1;
#X obj 50 65 metro 100;
#X text 203 212 reset internal data storage;
#X text 182 26 input values matches the creation;
#X text 183 42 arguments;
#X text 185 82 this can be changed in the sources !;
#X text 83 351 <-- 'bang' when input matches arguments;
#X obj 62 122 hdl 20 1 0 5 empty empty empty 0 -6 0 8 -262144 -1 -1
0;
#X floatatom 50 154 5 0 0;
#X text 228 229 -> forget all old values;
#X obj 50 243 match 3 4;
#X floatatom 81 325 5 0 0;
#X floatatom 156 324 5 0 0;
#X obj 81 294 unpack f f;
#X text 111 11 match :: outputs a list when a list of;
#X msg 93 178 1 3 4 7;
#X msg 160 178 1 2 4 5;
#X text 230 179 send a list of floats;
#X symbolatom 688 312 10 0 0;
#X symbolatom 616 336 10 0 0;
#X symbolatom 581 356 10 0 0;
#X obj 540 349 bng 24 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
-1;
#X obj 540 244 match dog bytes 2 cats;
#X msg 553 186 dog bytes 2 cats;
#X msg 564 214 cat bytes 2 dogs;
#X text 384 114 same works for symbols and mixtures of floats and symbols:
;
#X obj 581 285 unpack s s f s;
#X floatatom 635 313 5 0 0;
#X text 89 271 sends out the list when a match is found;
#X msg 459 151 dog;
#X msg 494 143 cats;
#X msg 519 170 2;
#X msg 471 195 bytes;
#X text 183 68 a maximum of 16 arguments is allowed;
#X connect 1 0 14 0;
#X connect 2 0 12 0;
#X connect 3 0 5 0;
#X connect 4 0 5 0;
#X connect 5 0 2 0;
#X connect 11 0 12 0;
#X connect 12 0 14 0;
#X connect 14 0 0 0;
#X connect 14 0 17 0;
#X connect 17 0 15 0;
#X connect 17 1 16 0;
#X connect 19 0 14 0;
#X connect 20 0 14 0;
#X connect 26 0 25 0;
#X connect 26 0 30 0;
#X connect 27 0 26 0;
#X connect 28 0 26 0;
#X connect 30 0 24 0;
#X connect 30 1 23 0;
#X connect 30 2 31 0;
#X connect 30 3 22 0;
#X connect 33 0 26 0;
#X connect 34 0 26 0;
#X connect 35 0 26 0;
#X connect 36 0 26 0;
--- NEW FILE: help-arbran.pd ---
#N canvas 190 136 663 491 12;
#X obj 41 152 bng 20 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
-1;
#X floatatom 41 249 5 0 0;
#N canvas 0 0 450 300 graph1 0;
#X array array1 6 float 1;
#A 0 1.1 2.67143 3.24285 3.1 4.38571 8.67143;
#X coords 0 10 5 0 200 140 1;
#X restore 347 71 graph;
#N canvas 0 0 450 300 graph2 0;
#X array array2 6 float 1;
#A 0 0.0229077 0.204366 0.486501 0.0632986 0.204028 0.025319;
#X coords 0 1 5 0 200 140 1;
#X restore 347 220 graph;
#X obj 41 202 arbran array1 array2;
#X text 39 21 arbran :: generates a random variable that conforms
to the piecewise probability density functions specified in two arrays
;
#X text 40 297 array1 has values between 0 and 10;
#X text 40 317 array2 between 0 and 1 !;
#X msg 99 152 pdfscale;
#X text 41 389 array1 stores the values and array2 the corresponding
probabilities (0 - 1) for each of that values \, use message 'pdfscale'
to check (and adjust) the probability values to correct settings (the
area below the curve has to be 1);
#X connect 0 0 4 0;
#X connect 4 0 1 0;
#X connect 8 0 4 0;
--- NEW FILE: help-timebang.pd ---
#N canvas 207 138 549 342 12;
#X obj 29 242 bng 20 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
-1;
#X obj 29 295 print good morning;
#X obj 29 202 timebang 7 10 13 19 47 50;
#X obj 224 235 print good night;
#X text 32 13 timebang :: send out bangs at given times of day;
#X text 130 34 written by Olaf Matthes <olaf.matthes(a)gmx.de>;
#X text 31 119 creation arguments: triples of hour minute and second
for;
#X text 191 137 the times of day you want a bang to occur;
#X text 191 156 each time will get it's own outlet;
#X text 184 297 this gets banged at 7:10:13 in the morning;
#X text 224 257 this gets banged at 19:47:50;
#X connect 0 0 1 0;
#X connect 2 0 0 0;
#X connect 2 1 3 0;
--- NEW FILE: help-wrap.pd ---
#N canvas 328 32 562 465 12;
#X floatatom 27 304 8 0 0 0 - - -;
#X floatatom 27 73 5 0 0 0 - - -;
#X text 187 26 written by <olaf.matthes(a)gmx.de>;
#X floatatom 60 133 5 0 0 0 - - -;
#X floatatom 94 158 5 0 0 0 - - -;
#X text 84 71 input value;
#X text 57 102 creation arguments can be changed dynamically:;
#X text 35 341 creation arguments:;
#X text 115 132 lower limit;
#X text 146 157 upper limit;
#X floatatom 94 277 5 0 0 0 - - -;
#X obj 27 249 wrap 6 40;
#X text 36 358 wrap <lower limit> <upper limit>;
#X text 106 305 floats 'in range';
#X text 122 11 wrap :: wrap floats into a range;
#X text 153 276 wrap periods;
#X connect 1 0 11 0;
#X connect 3 0 11 1;
#X connect 4 0 11 2;
#X connect 11 0 0 0;
#X connect 11 1 10 0;
--- NEW FILE: help-multi.pd ---
#N canvas 328 264 464 316 12;
#X floatatom 54 217 5 0 0;
#X floatatom 54 127 5 0 0;
#X floatatom 108 128 5 0 0;
#X text 39 20 multi :: like '*' but calculates result;
#X text 133 204 use creation arguments to set initial;
#X text 133 220 values for inlets;
#X msg 23 83 bang;
#X text 69 82 calculate and output result now;
#X obj 54 172 multi 8 6 2;
#X floatatom 163 129 5 0 0;
#X text 120 38 when leftmost or second inlet is changed;
#X connect 1 0 8 0;
#X connect 2 0 8 1;
#X connect 6 0 8 0;
#X connect 8 0 0 0;
#X connect 9 0 8 2;
--- NEW FILE: help-pitch.pd ---
#N canvas 166 313 439 308 12;
#X floatatom 83 266 5 0 0;
#X obj 83 35 notein;
#X floatatom 112 217 5 0 0;
#X floatatom 127 191 5 0 0;
#X floatatom 142 166 5 0 0;
#X floatatom 24 33 5 0 0;
#X symbolatom 97 242 7 0 0;
#X text 139 267 MIDI note number;
#X text 166 217 pitch class;
#X text 181 191 interval to last note;
#X text 197 166 register;
#X text 153 33 pitch :: get info about pitch;
#X text 169 243 note name (symbol);
#X text 221 54 use creation argument to;
#X text 221 71 set assumed first note;
#X text 227 104 of the first interval );
#X text 218 89 ( needed for calculation;
#X obj 83 94 stripnote;
#X obj 83 137 pitch 72;
#X connect 1 0 17 0;
#X connect 1 1 17 1;
#X connect 5 0 18 0;
#X connect 17 0 18 0;
#X connect 17 1 18 1;
#X connect 18 0 0 0;
#X connect 18 1 6 0;
#X connect 18 2 2 0;
#X connect 18 3 3 0;
#X connect 18 4 4 0;
--- NEW FILE: help-split.pd ---
#N canvas 328 32 560 463 12;
#X floatatom 27 304 8 0 0 0 - - -;
#X floatatom 27 73 5 0 0 0 - - -;
#X text 196 28 written by <olaf.matthes(a)gmx.de>;
#X floatatom 56 131 5 0 0 0 - - -;
#X floatatom 85 152 5 0 0 0 - - -;
#X text 84 71 input value;
#X text 57 104 creation arguments can be changed dynamically:;
#X text 35 341 creation arguments:;
#X obj 27 249 split 6 40;
#X text 111 130 lower limit;
#X text 137 151 upper limit;
#X text 35 378 All floats that fall below the lower limit or above
the upper limit get routed to the 2nd outlet.;
#X text 36 358 split <lower limit> <upper limit>;
#X floatatom 102 276 5 0 0 0 - - -;
#X text 154 276 floats 'out of range';
#X text 122 11 split :: split incoming floats according to value;
#X text 106 305 floats 'in range' (including borders!);
#X connect 1 0 8 0;
#X connect 3 0 8 1;
#X connect 4 0 8 2;
#X connect 8 0 0 0;
#X connect 8 1 13 0;
--- NEW FILE: help-history.pd ---
#N canvas 445 253 480 330 12;
#X floatatom 32 49 5 0 0;
#X floatatom 32 286 5 0 0;
#X floatatom 115 201 5 0 0;
#X floatatom 115 264 5 0 0;
#X text 169 265 tendency (up = 1 \, down = -1);
#X msg 85 70 reset;
#X text 137 71 forget everything;
#X msg 114 104 linear;
#X msg 132 128 geometric;
#X text 176 103 linear average (dafault);
#X text 215 129 geometric average;
#X msg 143 156 weight;
#X text 203 173 items higher weight);
#X text 124 6 history :: calculates the average of the;
#X text 212 23 items (floats) that came in;
#X obj 32 229 history 250;
#X text 202 157 weighted average (giving newer;
#X text 130 229 creation argument = ms to look back;
#X text 171 201 milliseconds to look back;
#X text 214 40 within the last N milliseconds;
#X text 90 287 average over last N milliseconds;
#X connect 0 0 15 0;
#X connect 2 0 15 1;
#X connect 5 0 15 0;
#X connect 7 0 15 0;
#X connect 8 0 15 0;
#X connect 11 0 15 0;
#X connect 15 0 1 0;
#X connect 15 1 3 0;
1
0
Update of /cvsroot/pure-data/externals/maxlib/maxlib/src
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv32589/src
Removed Files:
Tag: OLAFMATT
allow.c arbran.c arraycopy.c average.c beat.c beta.c bilex.c
borax.c cauchy.c chord.c delta.c deny.c dist.c divide.c
divmod.c edge.c expo.c fifo.c gauss.c gestalt.c history.c
ignore.c iso.c lifo.c limit.c linear.c listfifo.c listfunnel.c
match.c minus.c mlife.c multi.c nchange.c netclient.c
netdist.c netrec.c netserver.c nroute.c pitch.c plus.c
poisson.c pong.c pulse.c remote.c rewrap.c rhythm.c scale.c
score.c speedlim.c split.c step.c subst.c sync.c temperature.c
tilt.c timebang.c triang.c unroute.c urn.c velocity.c
weibull.c wrap.c
Log Message:
Doh! somehow this ended up in the wrong place
--- borax.c DELETED ---
--- temperature.c DELETED ---
--- edge.c DELETED ---
--- iso.c DELETED ---
--- triang.c DELETED ---
--- gauss.c DELETED ---
--- nchange.c DELETED ---
--- wrap.c DELETED ---
--- ignore.c DELETED ---
--- unroute.c DELETED ---
--- limit.c DELETED ---
--- netrec.c DELETED ---
--- bilex.c DELETED ---
--- expo.c DELETED ---
--- poisson.c DELETED ---
--- tilt.c DELETED ---
--- plus.c DELETED ---
--- timebang.c DELETED ---
--- netserver.c DELETED ---
--- pitch.c DELETED ---
--- divmod.c DELETED ---
--- mlife.c DELETED ---
--- deny.c DELETED ---
--- divide.c DELETED ---
--- linear.c DELETED ---
--- multi.c DELETED ---
--- minus.c DELETED ---
--- arbran.c DELETED ---
--- history.c DELETED ---
--- match.c DELETED ---
--- lifo.c DELETED ---
--- velocity.c DELETED ---
--- netdist.c DELETED ---
--- score.c DELETED ---
--- nroute.c DELETED ---
--- subst.c DELETED ---
--- weibull.c DELETED ---
--- step.c DELETED ---
--- pulse.c DELETED ---
--- chord.c DELETED ---
--- rhythm.c DELETED ---
--- beta.c DELETED ---
--- gestalt.c DELETED ---
--- pong.c DELETED ---
--- urn.c DELETED ---
--- allow.c DELETED ---
--- split.c DELETED ---
--- listfunnel.c DELETED ---
--- beat.c DELETED ---
--- rewrap.c DELETED ---
--- speedlim.c DELETED ---
--- average.c DELETED ---
--- arraycopy.c DELETED ---
--- delta.c DELETED ---
--- dist.c DELETED ---
--- scale.c DELETED ---
--- remote.c DELETED ---
--- fifo.c DELETED ---
--- cauchy.c DELETED ---
--- sync.c DELETED ---
--- listfifo.c DELETED ---
--- netclient.c DELETED ---
1
0
Update of /cvsroot/pure-data/externals/maxlib/maxlib/help
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv32589/help
Removed Files:
Tag: OLAFMATT
automata.txt examplescore.txt help-allow.pd help-arbran.pd
help-arraycopy.pd help-average.pd help-beat.pd help-beta.pd
help-bilex.pd help-borax.pd help-cauchy.pd help-chord.pd
help-delta.pd help-deny.pd help-dist.pd help-divide.pd
help-divmod.pd help-edge.pd help-expo.pd help-fifo.pd
help-gauss.pd help-gestalt.pd help-history.pd help-ignore.pd
help-iso.pd help-lifo.pd help-limit.pd help-linear.pd
help-listfifo.pd help-listfunnel.pd help-match.pd
help-maxlib.pd help-minus.pd help-mlife.pd help-multi.pd
help-nchange.pd help-netclient.pd help-netdist.pd
help-netrec.pd help-netserver.pd help-nroute.pd help-pitch.pd
help-plus.pd help-poisson.pd help-pulse.pd help-remote.pd
help-rewrap.pd help-rhythm.pd help-scale.pd help-score.pd
help-speedlim.pd help-split.pd help-step.pd help-subst.pd
help-sync.pd help-temperature.pd help-tilt.pd help-timebang.pd
help-triang.pd help-unroute.pd help-urn.pd help-velocity.pd
help-weibull.pd help-wrap.pd
Log Message:
Doh! somehow this ended up in the wrong place
--- help-divide.pd DELETED ---
--- help-bilex.pd DELETED ---
--- help-limit.pd DELETED ---
--- help-netserver.pd DELETED ---
--- help-lifo.pd DELETED ---
--- help-delta.pd DELETED ---
--- help-netclient.pd DELETED ---
--- help-expo.pd DELETED ---
--- help-rewrap.pd DELETED ---
--- automata.txt DELETED ---
--- examplescore.txt DELETED ---
--- help-deny.pd DELETED ---
--- help-maxlib.pd DELETED ---
--- help-ignore.pd DELETED ---
--- help-average.pd DELETED ---
--- help-beta.pd DELETED ---
--- help-sync.pd DELETED ---
--- help-urn.pd DELETED ---
--- help-rhythm.pd DELETED ---
--- help-borax.pd DELETED ---
--- help-score.pd DELETED ---
--- help-iso.pd DELETED ---
--- help-speedlim.pd DELETED ---
--- help-netdist.pd DELETED ---
--- help-step.pd DELETED ---
--- help-unroute.pd DELETED ---
--- help-subst.pd DELETED ---
--- help-velocity.pd DELETED ---
--- help-dist.pd DELETED ---
--- help-weibull.pd DELETED ---
--- help-listfunnel.pd DELETED ---
--- help-divmod.pd DELETED ---
--- help-poisson.pd DELETED ---
--- help-beat.pd DELETED ---
--- help-arraycopy.pd DELETED ---
--- help-edge.pd DELETED ---
--- help-gestalt.pd DELETED ---
--- help-triang.pd DELETED ---
--- help-pulse.pd DELETED ---
--- help-cauchy.pd DELETED ---
--- help-scale.pd DELETED ---
--- help-gauss.pd DELETED ---
--- help-listfifo.pd DELETED ---
--- help-minus.pd DELETED ---
--- help-remote.pd DELETED ---
--- help-allow.pd DELETED ---
--- help-temperature.pd DELETED ---
--- help-chord.pd DELETED ---
--- help-fifo.pd DELETED ---
--- help-netrec.pd DELETED ---
--- help-linear.pd DELETED ---
--- help-plus.pd DELETED ---
--- help-nchange.pd DELETED ---
--- help-tilt.pd DELETED ---
--- help-nroute.pd DELETED ---
--- help-mlife.pd DELETED ---
--- help-match.pd DELETED ---
--- help-arbran.pd DELETED ---
--- help-timebang.pd DELETED ---
--- help-wrap.pd DELETED ---
--- help-multi.pd DELETED ---
--- help-pitch.pd DELETED ---
--- help-split.pd DELETED ---
--- help-history.pd DELETED ---
1
0
externals/maxlib/maxlib HISTORY,1.1.1.1,NONE LICENSE,1.1.1.1,NONE README,1.1.1.1,NONE darwin_altpackage.pmsp,1.1.1.1,NONE darwin_package.pmsp,1.1.1.1,NONE install.bat,1.1.1.1,NONE makefile,1.1.1.1,NONE maxlib.c,1.1.1.1,NONE maxlib.dsp,1.1.1.1,NONE maxlib.dsw,1.1.1.1,NONE
by Hans-Christoph Steiner 20 Mar '04
by Hans-Christoph Steiner 20 Mar '04
20 Mar '04
Update of /cvsroot/pure-data/externals/maxlib/maxlib
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv32589
Removed Files:
Tag: OLAFMATT
HISTORY LICENSE README darwin_altpackage.pmsp
darwin_package.pmsp install.bat makefile maxlib.c maxlib.dsp
maxlib.dsw
Log Message:
Doh! somehow this ended up in the wrong place
--- maxlib.dsw DELETED ---
--- maxlib.c DELETED ---
--- install.bat DELETED ---
--- maxlib.dsp DELETED ---
--- darwin_altpackage.pmsp DELETED ---
--- README DELETED ---
--- LICENSE DELETED ---
--- HISTORY DELETED ---
--- makefile DELETED ---
--- darwin_package.pmsp DELETED ---
1
0
Update of /cvsroot/pure-data/externals/maxlib/src
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv24357/src
Removed Files:
allow.c arbran.c arraycopy.c average.c beat.c beta.c bilex.c
borax.c cauchy.c chord.c delta.c deny.c dist.c divide.c
divmod.c edge.c expo.c fifo.c gauss.c gestalt.c history.c
ignore.c iso.c lifo.c limit.c linear.c listfifo.c listfunnel.c
match.c minus.c mlife.c multi.c nchange.c netclient.c
netdist.c netrec.c netserver.c nroute.c pitch.c plus.c
poisson.c pong.c pulse.c remote.c rewrap.c rhythm.c scale.c
score.c speedlim.c split.c step.c subst.c sync.c temperature.c
tilt.c timebang.c triang.c unroute.c urn.c velocity.c
weibull.c wrap.c
Log Message:
removing olaf's sources so that I can properly import them using cvs import and vender/release tags
--- borax.c DELETED ---
--- temperature.c DELETED ---
--- edge.c DELETED ---
--- iso.c DELETED ---
--- triang.c DELETED ---
--- gauss.c DELETED ---
--- nchange.c DELETED ---
--- wrap.c DELETED ---
--- ignore.c DELETED ---
--- unroute.c DELETED ---
--- limit.c DELETED ---
--- netrec.c DELETED ---
--- bilex.c DELETED ---
--- expo.c DELETED ---
--- poisson.c DELETED ---
--- tilt.c DELETED ---
--- plus.c DELETED ---
--- timebang.c DELETED ---
--- netserver.c DELETED ---
--- pitch.c DELETED ---
--- divmod.c DELETED ---
--- mlife.c DELETED ---
--- deny.c DELETED ---
--- divide.c DELETED ---
--- linear.c DELETED ---
--- multi.c DELETED ---
--- minus.c DELETED ---
--- arbran.c DELETED ---
--- history.c DELETED ---
--- match.c DELETED ---
--- lifo.c DELETED ---
--- velocity.c DELETED ---
--- netdist.c DELETED ---
--- score.c DELETED ---
--- nroute.c DELETED ---
--- subst.c DELETED ---
--- weibull.c DELETED ---
--- step.c DELETED ---
--- pulse.c DELETED ---
--- chord.c DELETED ---
--- rhythm.c DELETED ---
--- beta.c DELETED ---
--- gestalt.c DELETED ---
--- pong.c DELETED ---
--- urn.c DELETED ---
--- allow.c DELETED ---
--- split.c DELETED ---
--- listfunnel.c DELETED ---
--- beat.c DELETED ---
--- rewrap.c DELETED ---
--- speedlim.c DELETED ---
--- average.c DELETED ---
--- arraycopy.c DELETED ---
--- delta.c DELETED ---
--- dist.c DELETED ---
--- scale.c DELETED ---
--- remote.c DELETED ---
--- fifo.c DELETED ---
--- cauchy.c DELETED ---
--- sync.c DELETED ---
--- listfifo.c DELETED ---
--- netclient.c DELETED ---
1
0
externals/maxlib HISTORY,1.3,NONE LICENSE,1.1.1.1,NONE README,1.3,NONE darwin_altpackage.pmsp,1.1,NONE darwin_package.pmsp,1.1,NONE install.bat,1.1,NONE makefile,1.6,NONE maxlib.c,1.4,NONE maxlib.dsp,1.1,NONE maxlib.dsw,1.1,NONE
by Hans-Christoph Steiner 20 Mar '04
by Hans-Christoph Steiner 20 Mar '04
20 Mar '04
Update of /cvsroot/pure-data/externals/maxlib
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv24357
Removed Files:
HISTORY LICENSE README darwin_altpackage.pmsp
darwin_package.pmsp install.bat makefile maxlib.c maxlib.dsp
maxlib.dsw
Log Message:
removing olaf's sources so that I can properly import them using cvs import and vender/release tags
--- maxlib.dsw DELETED ---
--- maxlib.c DELETED ---
--- install.bat DELETED ---
--- maxlib.dsp DELETED ---
--- darwin_altpackage.pmsp DELETED ---
--- README DELETED ---
--- LICENSE DELETED ---
--- HISTORY DELETED ---
--- makefile DELETED ---
--- darwin_package.pmsp DELETED ---
1
0