static void forpp_bang(t_forpp *x)
{
x->x_cur = x->x_beg;
outlet_float(x->x_obj.ob_outlet, x->x_cur);
x->x_cur += x->x_incr;
if(x->x_incr > 0)
{
if(x->x_cur <= x->x_end)
clock_delay(x->x_clock, x->x_delay);
else
{
clock_unset(x->x_clock);
clock_delay(x->x_clock2, x->x_delay);
}
}
else
{
if(x->x_cur >= x->x_end)
clock_delay(x->x_clock, x->x_delay);
else
{
clock_unset(x->x_clock);
clock_delay(x->x_clock2, x->x_delay);
}
}
}
static void forpp_stop(t_forpp *x)
{
if(x->x_incr > 0)
x->x_cur = x->x_end + 1;
else
x->x_cur = x->x_end - 1;
clock_unset(x->x_clock);
clock_unset(x->x_clock2);
}
bool flext::Timer::Reset()
{
#if FLEXT_SYS == FLEXT_SYS_PD
clock_unset(clk);
#elif FLEXT_SYS == FLEXT_SYS_MAX
clock_unset(clk);
if(queued) ::qelem_unset(qelem);
#else
#error Not implemented
#endif
return true;
}
void GemMan :: destroyWindow()
{
GemMan::pleaseDestroy=false;
// don't want to get rid of this
// if (s_singleContext) return;
// nothing to destroy...
if (!m_windowState) return;
stopRendering();
clock_unset(s_windowClock);
s_windowClock = NULL;
glFlush();
glFinish();
destroyGemWindow(gfxInfo);
m_windowState = 0;
windowCleanup();
// this should really go into the GemWinCreate<OS> files::
// reestablish the const glxContext
/* this crashes on linux with intel cards */
gemWinMakeCurrent(constInfo);
s_windowRun = 0;
}
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);
}
// Destroy
void autotune_free(t_autotune *x)
{
//dsp_free((t_object *)x); // Always call dsp_free first in this routine
unsigned int ti;
clock_unset(x->clock);
clock_free(x->clock);
fft_des(x->fx);
freebytes(x->cbi,0);
freebytes(x->cbf,0);
freebytes(x->cbo,0);
//freebytes(x->cbonorm,0);
freebytes(x->cbwindow,0);
freebytes(x->hannwindow,0);
freebytes(x->acwinv,0);
freebytes(x->frag,0);
freebytes(x->ffttime,0);
freebytes(x->fftfreqre,0);
freebytes(x->fftfreqim,0);
free(x->fk);
free(x->fb);
free(x->fc);
free(x->frb);
free(x->frc);
free(x->fsmooth);
free(x->fsig);
for (ti=0; ti<x->ford; ti++) {
free(x->fbuff[ti]);
}
free(x->fbuff);
free(x->ftvec);
}
static void qlist_rewind(t_qlist *x)
{
x->x_onset = 0;
if (x->x_clock) clock_unset(x->x_clock);
x->x_whenclockset = 0;
x->x_reentered = 1;
}
/*------------------------------------ senseXFree ---*/
static void
senseXFree(SenseXData * xx)
{
if (xx)
{
xx->fStopping = true;
if (xx->fPollClock)
{
clock_unset(xx->fPollClock);
clock_free(reinterpret_cast<t_object *>(xx->fPollClock));
xx->fPollClock = NULL;
}
if (xx->fPollQueue)
{
qelem_unset(xx->fPollQueue);
qelem_free(xx->fPollQueue);
xx->fPollQueue = NULL;
}
if (xx->fProxy)
{
freeobject(reinterpret_cast<t_object *>(xx->fProxy));
xx->fProxy = NULL;
}
}
} // senseXFree
static void incdec_mouseup(t_incdec *x, t_object *patcherview, t_pt pt, long modifiers)
{
x->f_mouse_down = 0;
clock_unset(x->f_clock);
ebox_invalidate_layer((t_ebox *)x, cream_sym_background_layer);
ebox_redraw((t_ebox *)x);
}
static void tab_cross_corr_tick(t_tab_cross_corr *x)
{
x->x_counter++;
if(x->x_counter < x->x_n)
{
iemarray_t *vec_src1, *vec_src2, *vec_dst;
t_float sum;
int j, m;
vec_src1 = x->x_beg_mem_src1 + x->x_counter;
vec_src2 = x->x_beg_mem_src2;
vec_dst = x->x_beg_mem_dst + x->x_counter;
m = x->x_size_src2;
sum = 0.0f;
for(j=0; j<m; j++)
{
sum += iemarray_getfloat(vec_src1, j)*iemarray_getfloat(vec_src2, j);
}
iemarray_setfloat(vec_dst, 0, sum*x->x_factor);
clock_delay(x->x_clock, x->x_delay);
}
else
{
t_garray *a;
clock_unset(x->x_clock);
outlet_bang(x->x_obj.ob_outlet);
a = (t_garray *)pd_findbyclass(x->x_sym_dst, garray_class);
garray_redraw(a);
}
}
// *********************************************************
// -(query handler)-----------------------------------------
void impmap_on_query(mapper_signal sig, mapper_id instance, const void *value,
int count, mapper_timetag_t *time)
{
t_signal_ref *ref = mapper_signal_user_data(sig);
if (!ref) {
post("implicitmap: no user data for signal '%s' in on_input()",
mapper_signal_name(sig));
}
impmap *x = ref->x;
int i, len = mapper_signal_length(sig);
float *valf = (float*)value;
for (i = 0; i < len; i++) {
if (ref->offset + i >= MAX_LIST) {
post("mapper: Maximum vector length exceeded!");
break;
}
if (valf)
x->snapshots->outputs[ref->offset + i] = valf[i];
}
x->query_count --;
if (x->query_count == 0) {
clock_unset(x->timeout);
impmap_output_snapshot(x);
}
}
static void s2f_stop(t_s2f *x){
x->x_stopped = 1;
if (x->x_on){
clock_unset(x->x_clock);
x->x_on = 0;
}
}
static void line_float(t_line *x, t_float f)
{
double timenow = clock_getsystime();
if (x->x_gotinlet && x->x_in1val > 0)
{
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_targettime = clock_getsystimeafter(x->x_in1val);
x->x_targetval = f;
line_tick(x);
x->x_gotinlet = 0;
x->x_1overtimediff = 1./ (x->x_targettime - timenow);
if (x->x_grain <= 0)
x->x_grain = DEFAULTLINEGRAIN;
clock_delay(x->x_clock,
(x->x_grain > x->x_in1val ? x->x_in1val : x->x_grain));
}
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 mtrack_setmode(t_mtrack *tp, int newmode)
{
if (tp->tr_mode == MTR_PLAYMODE)
{
clock_unset(tp->tr_clock);
tp->tr_ixnext = 0;
}
switch (tp->tr_mode = newmode)
{
case MTR_STEPMODE:
break;
case MTR_RECMODE:
binbuf_clear(tp->tr_binbuf);
tp->tr_prevtime = clock_getlogicaltime();
break;
case MTR_PLAYMODE:
tp->tr_atdelta = 0;
tp->tr_ixnext = 0;
tp->tr_prevtime = 0.;
mtrack_donext(tp);
break;
default:
loudbug_bug("mtrack_setmode");
}
}
void xeq_rewind(t_xeq *x)
{
xeqit_rewind(&x->x_autoit);
xeqit_rewind(&x->x_stepit); /* LATER rethink */
if (x->x_clock) clock_unset(x->x_clock);
x->x_whenclockset = 0;
}
static void snapshot_stop(t_snapshot *x)
{
x->x_stopped = 1;
if (x->x_on)
{
clock_unset(x->x_clock);
x->x_on = 0;
}
}
/*------------------------------------ senseXDoMessage ---*/
void
senseXDoMessage(SenseXData * xx)
{
if (! xx->fStopping)
{
short prevLock;
switch (xx->fState)
{
case kAwaitingFirstMessage:
prevLock = lockout_set(1);
if (0 > xx->fOnDelay)
{
clock_delay(xx->fPollClock, xx->fOnDelay);
xx->fState = kBetweenMessages;
}
else
{
outlet_int(xx->fResultOut, 1);
if (0 > xx->fOffDelay)
{
clock_delay(xx->fPollClock, xx->fOffDelay);
xx->fState = kAfterSecondMessage;
}
else
{
outlet_int(xx->fResultOut, 0);
xx->fState = kAwaitingFirstMessage;
}
}
lockout_set(prevLock);
break;
case kBetweenMessages:
prevLock = lockout_set(1);
outlet_int(xx->fResultOut, 1);
clock_unset(xx->fPollClock);
if (0 < xx->fOffDelay)
{
clock_delay(xx->fPollClock, xx->fOffDelay);
xx->fState = kAfterSecondMessage;
}
else
{
outlet_int(xx->fResultOut, 0);
xx->fState = kAwaitingFirstMessage;
}
lockout_set(prevLock);
break;
default:
break;
}
}
} // senseXDoMessage
static void s2f_correct(t_s2f *x){
int wason = x->x_on;
x->x_offset = (x->x_rqoffset < x->x_nblock ? x->x_rqoffset : x->x_nblock - 1);
x->x_npoints = x->x_deltime * x->x_ksr - x->x_nblock + x->x_offset;
if((x->x_on = !x->x_stopped)){
if(!wason) x->x_nleft = x->x_offset;
}
else if(wason)
clock_unset(x->x_clock);
}
void scope_tick(t_scope *x)
{
ebox_invalidate_layer((t_ebox *)x, gensym("signal_layer"));
ebox_redraw((t_ebox *)x);
if(!sys_getdspstate())
{
x->f_startclock = 0;
clock_unset(x->f_clock);
}
}
static void scope_tick(t_scope *x)
{
ebox_invalidate_layer((t_ebox *)x, cream_sym_signal_layer);
ebox_redraw((t_ebox *)x);
if(!canvas_dspstate)
{
x->f_startclock = 0;
clock_unset(x->f_clock);
}
}
static void snapshot_correct(t_snapshot *x)
{
int wason = x->x_on;
x->x_offset =
(x->x_rqoffset < x->x_nblock ? x->x_rqoffset : x->x_nblock - 1);
x->x_npoints = x->x_deltime * x->x_ksr - x->x_nblock + x->x_offset;
if (x->x_on = (!x->x_stopped && x->x_deltime > 0.))
{
if (!wason) x->x_nleft = x->x_offset; /* CHECKME */
}
else if (wason) clock_unset(x->x_clock);
}
static void line_stop(t_line *x)
{
if (pd_compatibilitylevel >= 48)
{
if (clock_getsystime() >= x->x_targettime)
x->x_setval = x->x_targetval;
else x->x_setval += x->x_1overtimediff *
(clock_getsystime() - x->x_prevtime) *
(x->x_targetval - x->x_setval);
}
x->x_targetval = x->x_setval;
clock_unset(x->x_clock);
}
static void rvu_tilde_float(t_rvu_tilde *x, t_floatarg f)
{
if(f == 0.0f)
{
clock_unset(x->x_clock_metro);
x->x_started = 0;
}
else
{
clock_delay(x->x_clock_metro, x->x_metro_time);
x->x_started = 1;
}
}
/////////////////////////////////////////////////////////
// stopRendering
//
/////////////////////////////////////////////////////////
void GemMan :: stopRendering()
{
if (!m_rendering) return;
m_rendering = 0;
clock_unset(s_clock);
s_hit = 1;
// clean out all of the gemheads
renderChain(gensym("__gem_render"), false);
renderChain(gensym("__gem_render_osd"), false);
logpost(NULL, 3, "GEM: Stop rendering");
}
static int oggread_decode_input(t_oggread *x)
{
long ret; /* bytes per channel returned by decoder */
int i;
float **pcm;
x->x_vi = ov_info(&x->x_ov, x->x_current_section);
while(!x->x_eos)
{
ret = ov_read_float(&x->x_ov, &pcm, READ, &x->x_current_section);
if (ret == 0)
{
/* EOF */
x->x_eos = 1;
x->x_stream = 0;
clock_unset(x->x_clock);
// post("oggread~: end of file detected, stopping");
outlet_bang(x->x_out_end);
}
else if (ret < 0)
{
/* error in the stream. Not a problem, just reporting it in
case we (the app) cares. In this case, we don't. */
}
else
{
/* we don't bother dealing with sample rate changes, etc, but
you'll have to */
long j;
for(j = 0; j < ret; j++)
{
for(i = 0; i < x->x_vi->channels; i++)
{
x->x_outbuffer[x->x_outwriteposition] = pcm[i][j];
x->x_outwriteposition = (x->x_outwriteposition + 1)%x->x_outbuffersize;
}
}
x->x_outunread += (t_int)ret * x->x_vi->channels;
}
break;
}
x->x_decoded = (t_int)ret * x->x_vi->channels; /* num. of samples we got from decoder */
x->x_position = (t_float)ov_time_tell(&x->x_ov);
/* exit decoding 'loop' here, we'll get called again by perform() */
return 1;
}
void xeq_stop(t_xeq *x)
{
x->x_autoit.i_restarted = 1; /* LATER rethink */
if (x->x_clock) clock_unset(x->x_clock);
if (x->x_whenclockset != 0)
{
float elapsed = clock_gettimesince(x->x_whenclockset);
float left = x->x_clockdelay - elapsed;
if (left < 0) left = 0;
x->x_autoit.i_playloc.l_delay = left / x->x_tempo;
#if 0
post("stop: delay set to %f (user %f)",
x->x_autoit.i_playloc.l_delay, left);
#endif
x->x_whenclockset = 0;
}
}
static void setLineParameters(t_tripleLine *x, t_symbol *s, int argc, t_atom *argv)
{
float numCounts;
int i;
t_atom newargv[3];
float time = x->destTime;
clock_unset(x->clock);
if (argc == 4) time = atom_getfloat(&argv[3]);
else if (argc != 3)
{
error("tripleLine: requires 3 or 4 args");
return;
}
x->destTime = time;
numCounts = time / x->grain;
if (x->destTime <= 0.)
{
x->curTime = 0;
for (i = 0; i < 3; i++)
{
x->curVal[i] = x->destVal[i] = atom_getfloat(&argv[i]);
SETFLOAT((&newargv[i]), x->curVal[i]);
}
outlet_list(x->t_out1, &s_list, 3, newargv);
return;
}
else
{
for (i = 0; i < 3; i++)
{
x->destVal[i] = atom_getfloat(&argv[i]);
x->stepVal[i] = (x->destVal[i] - x->curVal[i]) / numCounts;
SETFLOAT((&newargv[i]), x->curVal[i]);
}
}
x->curTime = 0;
clock_delay(x->clock, x->grain);
outlet_list(x->t_out1, &s_list, 3, newargv);
}
/* set the clock to call back at an absolute system time */
void clock_set(t_clock *x, double setticks)
{
if (setticks < sys_time) setticks = sys_time;
clock_unset(x);
x->c_settime = setticks;
if (clock_setlist && clock_setlist->c_settime <= setticks)
{
t_clock *cbefore, *cafter;
for (cbefore = clock_setlist, cafter = clock_setlist->c_next;
cbefore; cbefore = cafter, cafter = cbefore->c_next)
{
if (!cafter || cafter->c_settime > setticks)
{
cbefore->c_next = x;
x->c_next = cafter;
return;
}
}
}
else x->c_next = clock_setlist, clock_setlist = x;
}
/*------------------------------------ x10Free ---*/
static void
x10Free(X10ControlData * xx)
{
if (xx)
{
xx->fStopping = true;
if (xx->fPollClock)
{
clock_unset(xx->fPollClock);
clock_free(reinterpret_cast<t_object *>(xx->fPollClock));
xx->fPollClock = NULL;
}
if (xx->fPollQueue)
{
qelem_unset(xx->fPollQueue);
qelem_free(xx->fPollQueue);
xx->fPollQueue = NULL;
}
FREE_BYTES(xx->fOutBuffer);
}
} // x10Free
/* take the scheduler forward one DSP tick, also handling clock timeouts */
void sched_tick(double next_sys_time)
{
int countdown = 5000;
while (clock_setlist && clock_setlist->c_settime < next_sys_time)
{
t_clock *c = clock_setlist;
sys_time = c->c_settime;
clock_unset(clock_setlist);
outlet_setstacklim();
(*c->c_fn)(c->c_owner);
if (!countdown--)
{
countdown = 5000;
sys_pollgui();
}
if (sys_quit)
return;
}
sys_time = next_sys_time;
dsp_tick();
sched_diddsp++;
}
