void cavoc_rule (t_cavoc *x, t_symbol *msg, short argc, t_atom *argv)
{
int i;
short *rule = x->rule;
if( argc != 8 ){
error("the rule must be size 8");
return;
}
for( i = 0; i < 8; i++ ){
rule[i] = (short) atom_getfloatarg(i, argc, argv);
// post("%d",rule[i]);
}
}
static void search(lotkavolterra_struct *lotkavolterra, t_symbol *s, int argc, t_atom *argv) {
int not_found, not_expired = lotkavolterra -> lyap_limit;
int jump, i, iterations;
t_atom vars[M_var_count];
double temp_a = lotkavolterra -> a;
double temp_b = lotkavolterra -> b;
double temp_c = lotkavolterra -> c;
double temp_e = lotkavolterra -> e;
if (argc > 0) {
for (i = 0; i < M_var_count; i++) {
SETFLOAT(&vars[i], atom_getfloatarg(i, argc, argv));
}
} else {
for (i = 0; i < M_var_count; i++) {
SETFLOAT(&vars[i], lotkavolterra -> vars_init[i]);
}
}
do {
jump = 500;
not_found = 0;
iterations = 10000;
bad_params:
lotkavolterra -> a = (drand48() * (lotkavolterra -> a_hi - lotkavolterra -> a_lo)) + lotkavolterra -> a_lo;
lotkavolterra -> b = (drand48() * (lotkavolterra -> b_hi - lotkavolterra -> b_lo)) + lotkavolterra -> b_lo;
lotkavolterra -> c = (drand48() * (lotkavolterra -> c_hi - lotkavolterra -> c_lo)) + lotkavolterra -> c_lo;
lotkavolterra -> e = (drand48() * (lotkavolterra -> e_hi - lotkavolterra -> e_lo)) + lotkavolterra -> e_lo;
// put any preliminary checks specific to this fractal to eliminate bad_params
reset(lotkavolterra, NULL, argc, vars);
do { calc(lotkavolterra, lotkavolterra -> vars); } while(jump--);
lotkavolterra -> lyap_exp = lyapunov((void *) lotkavolterra, (t_gotfn) calc, M_var_count, (double *) lotkavolterra -> vars);
if (isnan(lotkavolterra -> lyap_exp)) { not_found = 1; }
if (lotkavolterra -> lyap_exp < lotkavolterra -> lyap_lo || lotkavolterra -> lyap_exp > lotkavolterra -> lyap_hi) { not_found = 1; }
not_expired--;
} while(not_found && not_expired);
reset(lotkavolterra, NULL, argc, vars);
if (!not_expired) {
post("Could not find a fractal after %d attempts.", (int) lotkavolterra -> lyap_limit);
post("Try using wider constraints.");
lotkavolterra -> a = temp_a;
lotkavolterra -> b = temp_b;
lotkavolterra -> c = temp_c;
lotkavolterra -> e = temp_e;
outlet_anything(lotkavolterra -> search_outlet, gensym("invalid"), 0, NULL);
} else {
lotkavolterra -> failure_ratio = (lotkavolterra -> lyap_limit - not_expired) / lotkavolterra -> lyap_limit;
make_results(lotkavolterra);
outlet_anything(lotkavolterra -> search_outlet, gensym("search"), M_search_count, lotkavolterra -> search_out);
}
}
// freq message - sets the radio frequency in Hz (Max and Pd)
//
// format: freq <frequency in Hz> [now]
//
// the optional 'now' argument, if equal to 1, sets frequency right now, if radio is running.
// if argument is not passed or equals zero (default) freq setting will be deferred until the radio
// gets reset.
//
void rtlsdr_freq (t_rtlsdr *x, t_symbol *mesg, short argc, t_atom *argv ) {
// char msg[100];
int now = 0; // default is to defer frequency setting until reset
if(argc < 1) {
post("freq: <frequency in Hz> [now]", 0);
return;
}
if(argc > 0) {
x->x_freq_hz = (long) atom_getfloatarg(0, argc,argv);
new_freq = (uint32_t) x->x_freq_hz;
// sprintf(msg, "freq: setting freq to: %f", x->x_freq_hz);
// post(msg, 0);
}
if(argc > 1 ) {
now = (int) atom_getfloatarg(1, argc,argv);
}
if(now == 0) {
// post("freq: deferred");
return; // don't set frequency now
}
// post("freq: immediate");
// note, if radio is off, nothing happens until its turned on
if(x->x_radio_is_running == 1) {
need_to_set_freq = 1;
}
}
void pix_video :: dimenMessCallback(void *data, t_symbol *s, int ac, t_atom *av)
{
GetMyClass(data)->dimenMess(static_cast<int>(atom_getfloatarg(0, ac, av)),
static_cast<int>(atom_getfloatarg(1, ac, av)),
static_cast<int>(atom_getfloatarg(2, ac, av)),
static_cast<int>(atom_getfloatarg(3, ac, av)),
static_cast<int>(atom_getfloatarg(4, ac, av)),
static_cast<int>(atom_getfloatarg(5, ac, av)) );
}
static void *lowshelf_new(t_symbol *s, int argc, t_atom *argv)
{
t_lowshelf *x = (t_lowshelf *)pd_new(lowshelf_class);
float freq = 0;
float slope = 0;
int db = 0;
/////////////////////////////////////////////////////////////////////////////////////
int argnum = 0;
while(argc > 0)
{
if(argv -> a_type == A_FLOAT)
{ //if current argument is a float
t_float argval = atom_getfloatarg(0, argc, argv);
switch(argnum)
{
case 0:
freq = argval;
break;
case 1:
slope = argval;
break;
case 2:
db = argval;
break;
default:
break;
};
argnum++;
argc--;
argv++;
}
else if (argv -> a_type == A_SYMBOL)
{
goto errstate;
}
};
/////////////////////////////////////////////////////////////////////////////////////
x->x_inlet_freq = inlet_new((t_object *)x, (t_pd *)x, &s_signal, &s_signal);
pd_float((t_pd *)x->x_inlet_freq, freq);
x->x_inlet_q = inlet_new((t_object *)x, (t_pd *)x, &s_signal, &s_signal);
pd_float((t_pd *)x->x_inlet_q, slope);
x->x_inlet_amp = inlet_new((t_object *)x, (t_pd *)x, &s_signal, &s_signal);
pd_float((t_pd *)x->x_inlet_amp, db);
x->x_out = outlet_new((t_object *)x, &s_signal);
return (x);
errstate:
pd_error(x, "lowshelf~: improper args");
return NULL;
}
static void *select_new(t_symbol *s, int argc, t_atom *argv)
{
#ifdef ROCKBOX
(void) s;
#endif
t_atom a;
if (argc == 0)
{
argc = 1;
SETFLOAT(&a, 0);
argv = &a;
}
if (argc == 1)
{
t_sel1 *x = (t_sel1 *)pd_new(sel1_class);
x->x_atom = *argv;
x->x_outlet1 = outlet_new(&x->x_obj, &s_bang);
if (argv->a_type == A_FLOAT)
{
floatinlet_new(&x->x_obj, &x->x_atom.a_w.w_float);
x->x_outlet2 = outlet_new(&x->x_obj, &s_float);
}
else
{
symbolinlet_new(&x->x_obj, &x->x_atom.a_w.w_symbol);
x->x_outlet2 = outlet_new(&x->x_obj, &s_symbol);
}
return (x);
}
else
{
int n;
t_selectelement *e;
t_sel2 *x = (t_sel2 *)pd_new(sel2_class);
x->x_nelement = argc;
x->x_vec = (t_selectelement *)getbytes(argc * sizeof(*x->x_vec));
x->x_type = argv[0].a_type;
for (n = 0, e = x->x_vec; n < argc; n++, e++)
{
e->e_outlet = outlet_new(&x->x_obj, &s_bang);
if ((x->x_type = argv->a_type) == A_FLOAT)
e->e_w.w_float = atom_getfloatarg(n, argc, argv);
else e->e_w.w_symbol = atom_getsymbolarg(n, argc, argv);
}
x->x_rejectout = outlet_new(&x->x_obj, &s_float);
return (x);
}
}
void *volctl_new(t_symbol *s, int argc, t_atom *argv)
{
if (argc > 3) post("volctl~: extra arguments ignored");
t_volctl *x = (t_volctl *)pd_new(volctl_class);
inlet_new(&x->x_obj, &x->x_obj.ob_pd, &s_float, gensym("f1"));
inlet_settip(x->x_obj.ob_inlet,gensym("factor"));
x->x_value = atom_getfloatarg(0, argc, argv);
t_inlet * time = floatinlet_new(&x->x_obj, &x->x_h);
inlet_settip(time,gensym("interpolation_time"));
x->x_h = atom_getfloatarg(1, argc, argv);
x->x_samples_per_ms = 44100.f / 1000.f; // assume default samplerate
x->x_blocksize = 64;
x->x_1overblocksize = 1.f/64.f;
outlet_new(&x->x_obj, &s_signal);
x->x_f = 0;
x->x_slopes = getalignedbytes(4*sizeof(t_float));
return (x);
}
void adsr_list (t_adsr *x, t_atom *msg, short argc, t_atom *argv)
{
x->rsamps = x->tsamps - (x->asamps+x->dsamps+x->ssamps);
if( x->rsamps < 0 )
x->rsamps = 0;
x->a = (atom_getfloatarg(0,argc,argv)) * .001;
x->d = (atom_getfloatarg(1,argc,argv)) * .001;
x->s = (atom_getfloatarg(2,argc,argv)) * .001;
x->r = (atom_getfloatarg(3,argc,argv)) * .001;
x->asamps = x->a * x->srate;
x->dsamps = x->d * x->srate;
x->ssamps = x->s * x->srate;
x->rsamps = x->r * x->srate;
x->tsamps = x->asamps+x->dsamps+x->ssamps+x->rsamps;
x->ebreak1 = x->asamps;
x->ebreak2 = x->asamps+x->dsamps;
x->ebreak3 = x->asamps+x->dsamps+x->ssamps;
}
/* new values from dialog window */
void glob_audio_dialog(t_pd *dummy, t_symbol *s, int argc, t_atom *argv)
{
int i, nindev, noutdev;
int newaudioindev[4], newaudioinchan[4],
newaudiooutdev[4], newaudiooutchan[4];
/* the new values the dialog came back with: */
int newrate = atom_getfloatarg(16, argc, argv);
int newadvance = atom_getfloatarg(17, argc, argv);
int newcallback = atom_getfloatarg(18, argc, argv);
int newblocksize = atom_getfloatarg(19, argc, argv);
for (i = 0; i < 4; i++)
{
newaudioindev[i] = atom_getfloatarg(i, argc, argv);
newaudioinchan[i] = atom_getfloatarg(i+4, argc, argv);
newaudiooutdev[i] = atom_getfloatarg(i+8, argc, argv);
newaudiooutchan[i] = atom_getfloatarg(i+12, argc, argv);
}
for (i = 0, nindev = 0; i < 4; i++)
{
if (newaudioinchan[i])
{
newaudioindev[nindev] = newaudioindev[i];
newaudioinchan[nindev] = newaudioinchan[i];
/* post("in %d %d %d", nindev,
newaudioindev[nindev] , newaudioinchan[nindev]); */
nindev++;
}
}
for (i = 0, noutdev = 0; i < 4; i++)
{
if (newaudiooutchan[i])
{
newaudiooutdev[noutdev] = newaudiooutdev[i];
newaudiooutchan[noutdev] = newaudiooutchan[i];
/* post("out %d %d %d", noutdev,
newaudiooutdev[noutdev] , newaudioinchan[noutdev]); */
noutdev++;
}
}
sys_set_audio_settings_reopen(nindev, newaudioindev, nindev, newaudioinchan,
noutdev, newaudiooutdev, noutdev, newaudiooutchan,
newrate, newadvance, newcallback, newblocksize);
}
void chopper_set_loop(t_chopper *x, t_symbol *msg, short argc, t_atom *argv)
{
if( argc < 3 ){
error("format: start samples increment");
return;
}
x->loop_start = atom_getintarg(0,argc,argv);
x->loop_samps = atom_getintarg(1,argc,argv);
x->increment = atom_getfloatarg(2,argc,argv);
x->data_recalled = 1;
x->samps_to_go = x->loop_samps;
x->fbindex = x->bindex = x->loop_start;
// post("loop set to: st %d samps %d incr %f", x->loop_start, x->loop_samps,x->increment);
}
static void *toany_new(t_symbol *sel, int argc, t_atom *argv){
t_symbol *dummy = sel;
dummy = NULL;
t_toany *x = (t_toany *)pd_new(toany_class);
int bufsize = 256;
x->x_binbuf = binbuf_new();
x->x_eos = -1;
if(argc)
x->x_eos = atom_getfloatarg(0, argc, argv);
toany_char_code_clear(&x->x_char_code);
toany_char_code_realloc(&x->x_char_code, bufsize);
x->x_eos_in = floatinlet_new(&x->x_obj, &x->x_eos);
x->x_outlet = outlet_new(&x->x_obj, &s_list);
return (void *)x;
}
static short get_device_number_from_arguments(int argc, t_atom *argv)
{
short device_number = -1;
t_symbol *first_argument;
if(argc == 1)
{
first_argument = atom_getsymbolarg(0,argc,argv);
if(first_argument == &s_)
{ // single float arg means device #
device_number = (short) atom_getfloatarg(0,argc,argv);
}
}
return device_number;
}
static void stdout_binary(t_stdout *x, int argc, t_atom *argv)
{
#define BUFSIZE 65535
char buf[BUFSIZE];
int i;
if (argc>BUFSIZE)
argc = BUFSIZE;
for (i=0; i<argc; i++)
((unsigned char *)buf)[i] = atom_getfloatarg(i, argc, argv);
buf[i>BUFSIZE?BUFSIZE:i] = 0;
fwrite(buf, 1, argc, stdout);
if (x->x_flush || !argc)
fflush(stdout);
}
void samm_ratiobeats(t_samm *x, t_symbol *msg, short argc, t_atom *argv)
{
int i,j;
double num,denom;
if(argc != x->metro_count * 2){
error("%s: arguments did not match metro count %d",x->metro_count);
return;
}
for(i = 0, j= 0; i < argc; i += 2, j++){
num = (double)atom_getfloatarg(i,argc,argv);
denom = (double)atom_getfloatarg(i+1,argc,argv);
if(!denom){
error("%s: zero divisor given for beat stream %d",OBJECT_NAME,(i/2)+1);
denom = 1.0;
}
x->metro_beatdurs[j] = 4.0 * (num / denom);
// post("beat duration %f",4.0 * (num/denom));
x->metro_samps[j] = x->metro_beatdurs[j] * x->onebeat_samps;
x->metro[j] = 1.0; // initialize for instantaneous beat
}
}
void *base3_new(t_symbol *s, int argc, t_atom *argv) {
base3_struct *base3 = (base3_struct *) pd_new(base3_class);
if (base3 != NULL) {
outlet_new(&base3 -> x_obj, &s_float);
base3 -> search_outlet = outlet_new(&base3 -> x_obj, &s_list);
base3 -> vars_outlet = outlet_new(&base3 -> x_obj, &s_list);
base3 -> params_outlet = outlet_new(&base3 -> x_obj, &s_list);
if (argc == M_param_count + M_var_count) {
base3 -> vars_init[M_x] = base3 -> vars[M_x] = (double) atom_getfloatarg(0, argc, argv);
base3 -> a = (double) atom_getfloatarg(1, argc, argv);
base3 -> b = (double) atom_getfloatarg(2, argc, argv);
} else {
if (argc != 0 && argc != M_param_count + M_var_count) {
post("Incorrect number of arguments for base3 fractal. Expecting 3 arguments.");
}
base3 -> vars_init[M_x] = 0.1;
base3 -> a = 1;
base3 -> b = 1;
}
constrain(base3, NULL, 0, NULL);
lyap(base3, -1000000.0, 1000000.0, M_failure_limit);
}
return (void *)base3;
}
void *granulesf_grist(t_granulesf *x, t_symbol *msg, short argc, t_atom *argv)
{
if(argc < 10 ){
error("grist takes 10 arguments:");
post("events horizon min_incr max_incr minpan maxpan minamp maxamp mindur maxdur");
return 0;
}
x->events = atom_getintarg(0,argc,argv);
x->horizon_ms = atom_getfloatarg(1,argc,argv);
x->min_incr = atom_getfloatarg(2,argc,argv);
x->max_incr = atom_getfloatarg(3,argc,argv);
x->minpan = atom_getfloatarg(4,argc,argv);
x->maxpan = atom_getfloatarg(5,argc,argv);
x->minamp = atom_getfloatarg(6,argc,argv);
x->maxamp = atom_getfloatarg(7,argc,argv);
x->mindur_ms = atom_getfloatarg(8,argc,argv);
x->maxdur_ms = atom_getfloatarg(9,argc,argv);
x->mindur = .001 * x->sr * x->mindur_ms ;
x->maxdur = .001 * x->sr * x->maxdur_ms;
x->horizon = .001 * x->sr * x->horizon_ms;
if(x->min_incr < 0){
x->min_incr *= -1.0;
}
if(x->max_incr < 0){
x->max_incr *= -1.0;
}
if(x->minpan < 0.0) {
x->minpan = 0.0;
}
if(x->maxpan > 1.0) {
x->maxpan = 1.0;
}
if(x->events < 0){
x->events = 0;
}
return 0;
}
static void maximum_list(t_maximum *x, t_symbol *s, int argc, t_atom *argv){
if(argc && argc <= PDCYMAXN){
int numfloats = 0; //counting floats, mainly we're interested if there's more than one float - DK
t_float second = 0;//second largest
t_float first = 0;//largest
int idx = 0; //current index
int fidx = 0; //index of largest
t_float curf = 0; //declare here so accessible outside while
while(argc){
if(argv->a_type == A_FLOAT){
numfloats++;
curf = atom_getfloatarg(0, argc, argv);
if(numfloats == 1){
second = curf;
first = curf;
fidx = idx;
}
else{
if(curf > first){
second = first;
first = curf;
fidx = idx;
}
else if(curf > second || numfloats == 2){
second = curf;
};
};
};
argc--;
argv++;
idx++;
};
if(numfloats >= 1){
x->x_lastidx = fidx;
x->x_test = second;
x->x_lastmax = first;
outlet_float(x->x_idxlet, x->x_lastidx);
outlet_float(x->x_maxlet, x->x_lastmax);
};
};
}
void *epluribus_new(t_symbol *msg, int argc, t_atom *argv)
{
t_epluribus *x;
int i;
x = (t_epluribus *)pd_new(epluribus_class);
x->incount = (int) atom_getfloatarg(0,argc,argv);
for(i = 0; i < x->incount - 1; i++){
inlet_new(&x->x_obj, &x->x_obj.ob_pd, gensym("signal"),gensym("signal"));
}
outlet_new(&x->x_obj, gensym("signal"));
outlet_new(&x->x_obj, gensym("signal"));
if(x->incount < 2 || x->incount > 256 ){
error("%s: there must be between 2 and 256 input vectors", OBJECT_NAME);
return (NULL);
}
x->inverse = 0; // by default don't do inverse behaviour
return (x);
}
void *granulesf_setscale(t_granulesf *x, t_symbol *msg, short argc, t_atom *argv)
{
int i;
float *pitchscale = x->pitchscale;
if( argc >= MAXSCALE ){
error("%d is the maximum size scale", MAXSCALE);
return 0;
}
if( argc < 2 ){
error("there must be at least 2 members in scale");
return 0;
}
for(i=0; i < argc; i++){
pitchscale[i] = atom_getfloatarg(i,argc,argv);
}
x->pitchsteps = argc;
return 0;
}
static void *mtx_isequal_new(t_symbol *s, int argc, t_atom *argv)
{
if (argc>1) post("mtx_isequal : extra arguments ignored");
if (argc) {
t_mtx_binscalar *x = (t_mtx_binscalar *)pd_new(mtx_isequalscalar_class);
floatinlet_new(&x->x_obj, &x->f);
x->f = atom_getfloatarg(0, argc, argv);
outlet_new(&x->x_obj, 0);
return(x);
} else {
t_mtx_binmtx *x = (t_mtx_binmtx *)pd_new(mtx_isequal_class);
inlet_new(&x->x_obj, &x->x_obj.ob_pd, gensym("matrix"), gensym(""));
outlet_new(&x->x_obj, 0);
x->m.col = x->m.row = x->m2.col = x->m2.row = 0;
x->m.atombuffer = x->m2.atombuffer = 0;
return(x);
}
}
void *tPlane3D_new(t_symbol *s, int argc, t_atom *argv)
{
t_tPlane3D *x = (t_tPlane3D *)pd_new(tPlane3D_class);
x->force_new=outlet_new(&x->x_obj, 0);
x->profondeur=outlet_new(&x->x_obj, 0);
x->vitesse=outlet_new(&x->x_obj, 0);
x->distance_old = 0;
if (argc>=7)
x->P= atom_getfloatarg(6, argc, argv);
else
x->P= 10000;
if (argc>=6)
x->Z= atom_getfloatarg(5, argc, argv);
else
x->Z= 0;
if (argc>=5)
x->Y= atom_getfloatarg(4, argc, argv);
else
x->Y= 0;
if (argc>=4)
x->X= atom_getfloatarg(3, argc, argv);
else
x->X= 0;
if (argc>=3)
x->VZ= atom_getfloatarg(2, argc, argv);
else
x->VZ= 0;
if (argc>=2)
x->VY= atom_getfloatarg(1, argc, argv);
else
x->VY= 0;
if (argc>=1)
x->VX= atom_getfloatarg(0, argc, argv);
else
x->VX= 1;
return (x);
}
void *channel_new(t_symbol *s, int argc, t_atom *argv)
{
#if MSP
t_channel *x = (t_channel *)newobject(channel_class);
intin(x,1);
dsp_setup((t_pxobject *)x,1);
outlet_new((t_object *)x, "signal");
#endif
#if PD
t_channel *x = (t_channel *)pd_new(channel_class);
outlet_new(&x->x_obj, gensym("signal"));
#endif
x->channel = (int)atom_getfloatarg(0,argc,argv);
// x->channel = 0;
return (x);
}
static void list_tosymbol_list(t_list_tosymbol *x, t_symbol *s,
int argc, t_atom *argv)
{
int i;
#if HAVE_ALLOCA
char *str = alloca(argc + 1);
#else
char *str = getbytes(argc + 1);
#endif
for (i = 0; i < argc; i++)
str[i] = (char)atom_getfloatarg(i, argc, argv);
str[argc] = 0;
outlet_symbol(x->x_obj.ob_outlet, gensym(str));
#if HAVE_ALLOCA
#else
freebytes(str, argc+1);
#endif
}
static void *t3_metro_new(t_symbol *s, int ac, t_atom *av)
{
t_t3_metro *x = (t_t3_metro *)pd_new(t3_metro_class);
x->x_metrotime = 10.0;
x->x_t3_bang = 0.0;
x->x_hit = 0;
if((ac == 1)&&IS_A_FLOAT(av,0))
{
t3_metro_ft1(x, atom_getfloatarg(0, ac, av));
}
x->x_ticks2ms = 1000.0*(double)sys_getblksize()/(double)sys_getsr();
x->x_clock = clock_new(x, (t_method)t3_metro_tick);
outlet_new(&x->x_obj, &s_float);
x->x_out_next = outlet_new(&x->x_obj, &s_float);
inlet_new(&x->x_obj, &x->x_obj.ob_pd, gensym("float"), gensym("ft1"));
return (x);
}
t_int *lpreson_tilde_perform(t_int *w)
{
t_object x_obj;
t_lpreson_tilde *x = (t_lpreson_tilde *)(w[1]);
t_lpreson_control *ctl = (t_lpreson_control *)(w[2]);
int n = (int)(w[3]);
t_float *in = ctl->c_residual;
t_float *out = ctl->c_output;
t_int ord = x->x_order;
float mem[ord+1];
/*
* Do the inverse filtering
*
* 'data_in' : residual signal (length 'len')
* 'data_out' : output frame (length 'len')
* 'coeff' : the parcor coefficients (length 'tap')
* 'lattice_iir' : filter memory - Previously initialised using init_lattice_iir_filter()
*
*/
int k, i;
float sri;
for (i=0;i<=ord;i++)
{
// SETFLOAT (&schur->x_parcors[i],0);
mem[i] = 0.0;
}
for (k = 0; k < n; k++ )
{
/* Synthesis filter - Lattice structure */
sri = in[k];
for (i=0; i<ord; i++)
{
t_float parcor = atom_getfloatarg ((ord-1-i),ord,ctl->x_parcors);
sri = sri - parcor * mem[ord-1-i];
mem[ord-i] = mem[ord-1-i] + parcor*sri;
}
out[k] = sri;
mem[0] = sri;
} /* next k */
return(w+4);
}
/* Set the send buffer size of socket, returns actual size */
static int tcpclient_set_socket_send_buf_size(t_tcpclient *x, int size)
{
int optVal = size;
int optLen = sizeof(int);
#ifdef _WIN32
if (setsockopt(x->x_fd, SOL_SOCKET, SO_SNDBUF, (char*)&optVal, optLen) == SOCKET_ERROR)
{
post("%s_set_socket_send_buf_size: setsockopt returned %d\n", objName, WSAGetLastError());
#else
if (setsockopt(x->x_fd, SOL_SOCKET, SO_SNDBUF, (char*)&optVal, optLen) == -1)
{
post("%s_set_socket_send_buf_size: setsockopt returned %d\n", objName, errno);
#endif
return 0;
}
else return (tcpclient_get_socket_send_buf_size(x));
}
/* Get/set the send buffer size of client socket */
static void tcpclient_buf_size(t_tcpclient *x, t_symbol *s, int argc, t_atom *argv)
{
float buf_size = 0;
if(x->x_connectstate == 0)
{
post("%s_buf_size: no clients connected", objName);
return;
}
/* get size of buffer (first element in list) */
if (argc > 0)
{
if (argv[0].a_type != A_FLOAT)
{
post("%s_buf_size: specify buffer size with a float", objName);
return;
}
buf_size = atom_getfloatarg(0, argc, argv);
x->x_fdbuf = tcpclient_set_socket_send_buf_size(x, (int)buf_size);
if (x->x_verbosity) post("%s_buf_size: set to %d", objName, x->x_fdbuf);
return;
}
x->x_fdbuf = tcpclient_get_socket_send_buf_size(x);
return;
}
static void search(base3_struct *base3, t_symbol *s, int argc, t_atom *argv) {
int not_found, not_expired = base3 -> lyap_limit;
int jump, i, iterations;
t_atom vars[M_var_count];
double temp_a = base3 -> a;
double temp_b = base3 -> b;
if (argc > 0) {
for (i = 0; i < M_var_count; i++) {
SETFLOAT(&vars[i], atom_getfloatarg(i, argc, argv));
}
} else {
for (i = 0; i < M_var_count; i++) {
SETFLOAT(&vars[i], base3 -> vars_init[i]);
}
}
do {
jump = 500;
not_found = 0;
iterations = 10000;
bad_params:
base3 -> a = (drand48() * (base3 -> a_hi - base3 -> a_lo)) + base3 -> a_lo;
base3 -> b = (drand48() * (base3 -> b_hi - base3 -> b_lo)) + base3 -> b_lo;
// put any preliminary checks specific to this fractal to eliminate bad_params
reset(base3, NULL, argc, vars);
do { calc(base3, base3 -> vars); } while(jump--);
base3 -> lyap_exp = lyapunov((void *) base3, (t_gotfn) calc, M_var_count, (double *) base3 -> vars);
if (isnan(base3 -> lyap_exp)) { not_found = 1; }
if (base3 -> lyap_exp < base3 -> lyap_lo || base3 -> lyap_exp > base3 -> lyap_hi) { not_found = 1; }
not_expired--;
} while(not_found && not_expired);
reset(base3, NULL, argc, vars);
if (!not_expired) {
post("Could not find a fractal after %d attempts.", (int) base3 -> lyap_limit);
post("Try using wider constraints.");
base3 -> a = temp_a;
base3 -> b = temp_b;
outlet_anything(base3 -> search_outlet, gensym("invalid"), 0, NULL);
} else {
base3 -> failure_ratio = (base3 -> lyap_limit - not_expired) / base3 -> lyap_limit;
make_results(base3);
outlet_anything(base3 -> search_outlet, gensym("search"), M_search_count, base3 -> search_out);
}
}
static void round_zero_anything(t_round_zero *x, t_symbol *s, int ac, t_atom *av)
{
int i;
t_float f, bound=x->x_bound;
for(i=0; i<ac; i++)
{
if(IS_A_FLOAT(av, i))
{
f = atom_getfloatarg(i, ac, av);
if((f <= bound)&&(f >= -bound))
{
f = 0.0f;
SETFLOAT(av+i, f);
}
}
}
outlet_anything(x->x_obj.ob_outlet, s, ac, av);
}
void samm_sampbeats(t_samm *x, t_symbol *msg, short argc, t_atom *argv)
{
int i;
double samples;
if(argc != x->metro_count){
error("%s: arguments did not match metro count %d",x->metro_count);
return;
}
for(i = 0; i < argc; i++){
samples = (double)atom_getfloatarg(i,argc,argv);
if(samples <= 0){
error("%s: illegal duration for beat stream %d",OBJECT_NAME,i+1);
samples = x->sr;
}
x->metro_samps[i] = samples;
x->metro_beatdurs[i] = x->metro_samps[i] / x->onebeat_samps; // just in case tempo changes
x->metro[i] = 1.0; // initialize for instantaneous beat
}
}
void *multigrain_setscale(t_multigrain *x, t_symbol *msg, short argc, t_atom *argv)
{
int i;
float *pitchscale = x->pitchscale;
if( argc >= MAXSCALE ){
error("%d is the maximum size scale", MAXSCALE);
return 0;
}
if( argc < 2 ){
error("there must be at least 2 members in scale");
return 0;
}
for(i=0; i < argc; i++){
pitchscale[i] = atom_getfloatarg(i,argc,argv);
}
x->pitchsteps = argc;
// post("read %d values into scale", x->pitchsteps);
return 0;
}
