//----------------------------------------------------------------------------------------------------------------
// udmx_int: a list received in the main inlet
//
// update dmx buffer, send immediately if we can
//----------------------------------------------------------------------------------------------------------------
void udmx_int(t_udmx *x, t_int16 n){
// x = the instance of the object; n = the int received in the left inlet
if (n > 255) n=255;
if (n < 0) n=0;
if (x->dmx_buffer[x->channel] == n) return; // do nothing if value did not change
x->dmx_buffer[x->channel] = n;
if (x->clock_running) { // we're over the speed limit, track changes for later
if (x->channel > x->channel_changed_max) x->channel_changed_max = x->channel;
if (x->channel < x->channel_changed_min) x->channel_changed_min = x->channel;
} else {
udmx_send_single(x,x->channel);
if (x->speedlim) {
// start clock
#ifdef PUREDATA // compiling for PUREDATA
clock_delay(x->m_clock,x->speedlim);
#else // compiling for MaxMSP
clock_fdelay(x->m_clock,x->speedlim);
#endif // Max/PD switch
x->clock_running = 1;
}
}
}
//----------------------------------------------------------------------------------------------------------------
// object creation
void *udmx_new(t_symbol *s, long argc, t_atom *argv) {
t_atom *ap;
t_int16 n;
n = 0;
// n = int argument typed into object box (A_DEFLONG) -- defaults to 0 if no args are typed
t_udmx *x = (t_udmx *)object_alloc(udmx_class);
intin(x,1); // create a second int inlet (leftmost inlet is automatic - all objects have one inlet by default)
x->m_clock = clock_new(x,(method)udmx_tick); // make new clock for polling and attach tick function to it
x->m_qelem = qelem_new((t_object *)x, (method)find_device);
x->msgOutlet = outlet_new(x,0L); //create right outlet
x->statusOutlet = outlet_new(x,0L); //create an outlet for connected flag
x->correct_adressing = 1;
if (argc) {
ap = argv;
switch (atom_gettype(ap)) {
case A_LONG:
n = atom_getlong(ap);
break;
default:
break;
}
ap = &argv[argc-1];
switch (atom_gettype(ap)) {
case A_LONG:
if (atom_getlong(ap) == 0 ) {
x->correct_adressing = 0;
}
break;
default:
break;
}
}
if(x->correct_adressing) {n = n - 1;}
if (n < 0) n = 0;
if (n > 511) n = 511;
x->channel = n;
x->debug_flag = 0;
x->channel_changed_min = 512;
x->channel_changed_max = -1;
x->clock_running = 0;
x->dev_handle = NULL;
x->speedlim = SPEED_LIMIT;
x->usb_devices_seen = -1;
clock_fdelay(x->m_clock,100);
usb_init();
return(x); // return a reference to the object instance
}
void meter_tick(t_meter *x)
{
meter_output(x);
if(x->f_ramp == x->f_vector->getNumberOfChannels())
x->f_ramp = 0;
x->f_vector->process(x->f_signals, x->f_vector_coords + x->f_vector->getNumberOfChannels() * x->f_ramp);
for(int i = 0; i < x->f_meter->getNumberOfChannels(); i++)
{
if(x->f_meter->getChannelEnergy(i) >= 0.)
x->f_overled[i] = OVERLED_DRAWTIME;
else
x->f_overled[i] -= x->f_interval;
if(x->f_overled[i] < 0)
x->f_overled[i] = 0;
}
jbox_invalidate_layer((t_object *)x, NULL, s_leds_layer);
jbox_invalidate_layer((t_object *)x, NULL, s_energy_layer);
jbox_invalidate_layer((t_object *)x, NULL, s_velocity_layer);
jbox_redraw((t_jbox *)x);
if (sys_getdspstate())
clock_fdelay(x->f_clock, x->f_interval);
}
void simpleFloat(t_simpleNeuron *s, double input) // input current
{
s->d_I = input;
int i;
if (s->l_ref == 0)
{
if (s->l_mode == 0)
s->d_V = s->d_V + s->d_I/s->d_C;
else if (s->l_mode == 1)
{
s->d_V = s->d_V + s->d_I/s->d_C - s->d_V/(s->d_R*s->d_C);
clock_fdelay(s->m_clock2, s->d_leakPer);
}
else if (s->l_mode == 2)
{
for (i = 0; i < 20; i++)
{
s->d_V = s->d_V + s->d_stepSize*(s->d_V - (s->d_V*s->d_V*s->d_V)/3 - s->d_W + s->d_I);
s->d_W = s->d_W + s->d_stepSize*(s->d_V - s->d_a - s->d_b*s->d_W)/s->d_tao; // calculate dW/dt
if (s->d_V > 1.9 && s->l_bangFlag == 0)
{
clock_fdelay(s->m_clock3, s->d_bangD);
s->l_bangFlag = 1;
}
}
}
if (s->l_mode == 2)
{
if (s->d_V > 1.9 && s->l_bangFlag == 0)
{
clock_fdelay(s->m_clock3, s->d_bangD);
s->l_bangFlag = 1;
} else if (s->d_W < 1 && s->l_bangFlag == 1)
s->l_bangFlag = 0;
}
else if (s->d_V > s->d_Vth)
{
clock_fdelay(s->m_clock3, s->d_bangD);
s->l_ref = 1;
clock_fdelay(s->m_clock1, s->d_absRef);
}
}
}
void hoa_scope_tick(t_hoa_scope *x)
{
x->f_scope->process(x->f_signals + x->f_index * x->f_scope->getNumberOfHarmonics());
jbox_invalidate_layer((t_object *)x, NULL, hoa_sym_harmonics_layer);
jbox_redraw((t_jbox *)x);
if (sys_getdspstate())
clock_fdelay(x->f_clock, x->f_interval);
}
void scope_tick(t_scope *x)
{
x->f_viewer->processContribAndRep(x->f_harmonicsValues);
jbox_invalidate_layer((t_object *)x, NULL, gensym("contrib_layer"));
jbox_invalidate_layer((t_object *)x, NULL, gensym("harmonics_layer"));
jbox_redraw((t_jbox *)x);
if (sys_getdspstate())
clock_fdelay(x->f_clock, x->f_interval);
}
//----------------------------------------------------------------------------------------------------------------
// udmx_list: a list received in the main inlet
//
// update dmx buffer, send immediately if we can
//----------------------------------------------------------------------------------------------------------------
void udmx_list(t_udmx *x, t_symbol *s, short ac, t_atom *av) {
t_uint16 i,chan,val,change_min,change_max;
change_min = 512;
change_max = 0;
for(i=0; i<ac; ++i,av++) {
#ifdef PUREDATA // compiling for PUREDATA
if (av->a_type==A_FLOAT) val = av->a_w.w_float;
else val = 0;
if (val > 255) val = 255;
if (val < 255) val = 0;
#else // compiling for MaxMSP
if (av->a_type==A_LONG) val = MIN(MAX(av->a_w.w_long, 0), 255);
else if (av->a_type==A_FLOAT) {
val = MIN(MAX(av->a_w.w_float * 255., 0), 255);
}
else val = 0;
#endif // Max/PD switch
chan = x->channel+i;
if (val != x->dmx_buffer[chan]) {
x->dmx_buffer[chan] = val;
if (change_min > chan) change_min = chan;
if (change_max < chan) change_max = chan;
}
}
if (change_min > change_max) return; // if there are no changes do nothing
if (x->clock_running) { // we're over the speed limit, track changes for later
if (change_min < x->channel_changed_min) x->channel_changed_min = change_min;
if (change_max > x->channel_changed_max) x->channel_changed_max = change_max;
} else {
if (change_max - change_min) udmx_send_range(x,change_min,change_max);
else udmx_send_single (x,change_min);
if (x->speedlim) {
// start clock -> prevent sending over speed limit
#ifdef PUREDATA // compiling for PUREDATA
clock_delay(x->m_clock,x->speedlim);
#else // compiling for MaxMSP
clock_fdelay(x->m_clock,x->speedlim);
#endif // Max/PD switch x->clock_running = 1;
}
}
}
void leak(t_simpleNeuron *s)
{
if (s->d_V > 0 && s->d_V < s->d_Vth)
{
s->d_V = s->d_V - s->d_V/(s->d_R*s->d_C);
//post("leak");
}
if(s->d_V > 0)
clock_fdelay(s->m_clock2, s->d_leakPer);
else
s->d_V = 0;
}
/*! \param tm relative time between periodic events (in seconds)
\param data user data
\return true on success
\note the first event will be delayed by tm
*/
bool flext::Timer::Periodic(double tm,void *data)
{
userdata = data;
period = tm;
#if FLEXT_SYS == FLEXT_SYS_PD
clock_delay(clk,tm*1000.);
#elif FLEXT_SYS == FLEXT_SYS_MAX
clock_fdelay(clk,tm*1000.);
#else
#error Not implemented
#endif
return true;
}
/*! \param tm absolute time (in seconds)
\param data user data
\param dopast if set events with times lying in the past will be triggered immediately, if not set they are ignored
\return true on success
*/
bool flext::Timer::At(double tm,void *data,bool dopast)
{
userdata = data;
period = 0;
#if FLEXT_SYS == FLEXT_SYS_PD
const double systm = clock_gettimesince(0);
double df = tm*1000.-systm;
if(dopast && df < 0) df = 0;
if(df >= 0)
clock_delay(clk,df);
#elif FLEXT_SYS == FLEXT_SYS_MAX
const double ms = tm*1000.;
double cur;
clock_getftime(&cur);
if(cur <= ms)
clock_fdelay(clk,ms-cur);
else if(dopast) // trigger timer is past
clock_fdelay(clk,0);
#else
#error Not implemented
#endif
return true;
}
void wsserver::start(long inlet, t_symbol *s, long ac, t_atom *av)
{
if (ac)
{
if (atom_gettype(av) == A_SYM)
{
// TODO: check that webroot path is valid
if (mCtx == NULL)
{
const char *options[] = {
"listening_ports", mPortNumber.Get(),
"document_root", atom_getsym(av)->s_name,
NULL
};
mServerName.SetFormatted(128, "ol.wsserver v. %s", VERSION);
memset(&mCallbacks, 0, sizeof(mCallbacks));
mCallbacks.websocket_connect = websocket_connect_handler;
mCallbacks.websocket_ready = websocket_ready_handler;
mCallbacks.websocket_data = websocket_data_handler;
mCallbacks.connection_close = websocket_close_handler;
for (int i=0; i<mNumConnectionsToAllocate; i++)
mConnections.Add(new ws_connection());
mCtx = mg_start(&mCallbacks, this /* so that we can get a pointer to this in the static mCallbacks */, options);
if(mCtx)
{
post("%s started on port(s) %s with web root [%s]\n", mServerName.Get(), mg_get_option(mCtx, "listening_ports"), mg_get_option(mCtx, "document_root"));
post("maximium %i clients\n", mNumConnectionsToAllocate);
clock_fdelay(mClock, 0.);
}
else
error("couldn't start server: perhaps port is allready being used?");
}
else
error("server already started");
}
else
error("missing argument for message start");
}
else
error("missing argument for message start");
}
//! \brief Callback function for system clock.
void flext::Timer::callback(Timer *tmr)
{
#if FLEXT_SYS == FLEXT_SYS_MAX
if(tmr->queued)
qelem_set(tmr->qelem);
else
#endif
tmr->Work();
if(tmr->period) {
// reschedule
#if FLEXT_SYS == FLEXT_SYS_PD
clock_delay(tmr->clk,tmr->period*1000.);
#elif FLEXT_SYS == FLEXT_SYS_MAX
clock_fdelay(tmr->clk,tmr->period*1000.);
#else
#error Not implemented
#endif
}
}
void tralala_mouseDown(t_tll *x, t_object *pv, t_pt pt, long m)
{
if (TLL_PT_INSIDE(pt)) {
//
long k;
x->cursor.x = pt.x - 1.;
x->cursor.y = pt.y - 1.;
x->origin.x = pt.x - 1.;
x->origin.y = pt.y - 1.;
if (m & eCapsLock) {
tralala_mouseUnselectAll(x);
tralala_mouseHitZone(x);
} else if (m & eCommandKey) {
tralala_mouseUnselectZone(x);
tralala_mouseAddNote(x);
} else if (!(k = tralala_mouseHitNote(x, m))) {
TLL_FLAG_SET(TLL_FLAG_LASSO);
} else {
if ((k == TLL_HIT_GRAB) || (k == TLL_HIT_PULL)) {
TLL_FLAG_SET(TLL_FLAG_GRAB);
}
}
if (TLL_FLAG_FALSE(TLL_FLAG_DAEMON)) {
clock_fdelay(x->daemonClock, TLL_CLOCK_DAEMON_WORK);
}
TLL_FLAG_SET(TLL_DIRTY_ZONE | TLL_DIRTY_NOTE);
jbox_redraw((t_jbox *)x);
//
}
}
void pictmeter_tick(t_pictmeter *x)
{
// for the astute student of the Max SDK:
//
// this method is called by the scheduler thread
// x->p_max is also accessed by the perform method in the audio thread
// we could use a mutex or critical region to protect the following block of code from having the value of x->p_max modified during its execution.
// however, mutexes and critical regions carry a performance penalty.
//
// in this case, due to the nature of what we are doing (drawing something every tenth of second showing the history of the previous samples),
// the mutex or critical region will not add anything to the object, or protect us from crashes, and it carries a performance penalty.
// so we have made a conscious decision to not use the aforementioned thread locking mechanisms.
if (x->p_value != x->p_max) {
x->p_value = x->p_max;
if (x->p_value > 1.)
x->p_value = 1.;
x->p_max = 0;
jbox_redraw((t_jbox *)x);
}
if (sys_getdspstate()) // if the dsp is still on, schedule a next pictmeter_tick() call
clock_fdelay(x->p_clock, 100);
}
void wsserver::onTimer()
{
outputData();
clock_fdelay(mClock, 5.); // schedule the next clock
}
void hoa_scope_tick(t_hoa_scope *x)
{
float value;
float one, two;
t_atom av[3];
t_atom red[3];
t_atom blue[3];
x->f_scope->process(x->f_signals + x->f_index * x->f_scope->getNumberOfHarmonics());
if (sys_getdspstate())
clock_fdelay(x->f_clock, 500.);
outlet_anything(x->f_out, gensym("reset"), 0, NULL);
atom_setfloat(red, 1);
atom_setfloat(red+1, 0);
atom_setfloat(red+2, 0);
atom_setfloat(blue, 0);
atom_setfloat(blue+1, 0);
atom_setfloat(blue+2, 1);
for(int i = 0; i < x->f_scope->getNumberOfRows(); i++)
{
one = 0;
two = (double)i / (double)(x->f_scope->getNumberOfRows() - 1) * CICM_PI;
value = x->f_scope->getValue(i, 0);
if(value < 0)
{
outlet_anything(x->f_out, gensym("glcolor"), 3, blue);
value= -value;
}
else
outlet_anything(x->f_out, gensym("glcolor"), 3, red);
atom_setfloat(av, value * sin(two) * cos(one));
atom_setfloat(av+1, value * cos(two));
atom_setfloat(av+2, value * sin(two) * sin(one));
outlet_anything(x->f_out, gensym("moveto"), 3, av);
for(int j = 1; j < x->f_scope->getNumberOfColumns(); j++)
{
one = (double)j / (double)x->f_scope->getNumberOfColumns() * CICM_2PI;
value = x->f_scope->getValue(i, j);
if(value < 0)
{
outlet_anything(x->f_out, gensym("glcolor"), 3, blue);
value= -value;
}
else
outlet_anything(x->f_out, gensym("glcolor"), 3, red);
atom_setfloat(av, value * sin(two) * cos(one));
atom_setfloat(av+1, value * cos(two));
atom_setfloat(av+2, value * sin(two) * sin(one));
outlet_anything(x->f_out, gensym("lineto"), 3, av);
}
one = 0;
value = x->f_scope->getValue(i, 0);
if(value < 0)
{
outlet_anything(x->f_out, gensym("glcolor"), 3, blue);
value= -value;
}
else
outlet_anything(x->f_out, gensym("glcolor"), 3, red);
atom_setfloat(av, value * sin(two) * cos(one));
atom_setfloat(av+1, value * cos(two));
atom_setfloat(av+2, value * sin(two) * sin(one));
outlet_anything(x->f_out, gensym("lineto"), 3, av);
}
for(int j = 0; j < x->f_scope->getNumberOfColumns(); j++)
{
one = (double)j / (double)x->f_scope->getNumberOfColumns() * CICM_2PI;
two = 0.;
value = x->f_scope->getValue(0, j);
if(value < 0)
{
outlet_anything(x->f_out, gensym("glcolor"), 3, blue);
value= -value;
}
else
outlet_anything(x->f_out, gensym("glcolor"), 3, red);
atom_setfloat(av, value * sin(two) * cos(one));
atom_setfloat(av+1, value * cos(two));
atom_setfloat(av+2, value * sin(two) * sin(one));
outlet_anything(x->f_out, gensym("moveto"), 3, av);
for(int i = 1; i < x->f_scope->getNumberOfRows(); i++)
{
two = (double)i / (double)(x->f_scope->getNumberOfRows() - 1) * CICM_PI;
value = x->f_scope->getValue(i, j);
if(value < 0)
{
outlet_anything(x->f_out, gensym("glcolor"), 3, blue);
value= -value;
}
else
outlet_anything(x->f_out, gensym("glcolor"), 3, red);
atom_setfloat(av, value * sin(two) * cos(one));
atom_setfloat(av+1, value * cos(two));
atom_setfloat(av+2, value * sin(two) * sin(one));
outlet_anything(x->f_out, gensym("lineto"), 3, av);
}
}
}
void hoa_meter_tick(t_hoa_meter *x)
{
jbox_redraw((t_jbox *)x);
if (sys_getdspstate())
clock_fdelay(x->f_clock, x->f_interval);
}
