void wsserver::tx(long inlet, t_symbol *s, long ac, t_atom *av)
{
if (ac)
{
if (ac == 1 && atom_gettype(av) == A_SYM)
{
for (int i=0; i<getMaxNConnections(); i++)
{
ws_connection* ws_conn = getConnection(i);
WDL_MutexLock(&ws_conn->mutex);
ws_conn->fromserver.SetFormatted(MAX_STRING, "rx %s", atom_getsym(av)->s_name);
ws_conn->newdatafromserver = true;
}
}
else if (ac == 2 && atom_gettype(av) == A_LONG)
{
ws_connection* ws_conn = getConnection(atom_getlong(av));
if (ws_conn) {
WDL_MutexLock(&ws_conn->mutex);
ws_conn->fromserver.SetFormatted(MAX_STRING, "rx %s", atom_getsym(av+1)->s_name);
ws_conn->newdatafromserver = true;
}
else
error("invalid client for message tx");
}
else
error("missing argument for message tx");
}
else
error("missing argument for message tx");
}
t_max_err ocontext_attr_prefix_set(t_ocontext *x, t_object *attr, long argc, t_atom *argv)
{
switch(atom_gettype(argv)){
case A_SYM:
{
t_symbol *s = atom_getsym(argv);
if(s->s_name[0] != '/'){
char buf[sizeof(s->s_name) + 2];
sprintf(buf, "/%s", s->s_name);
x->prefix = gensym(buf);
}else{
x->prefix = atom_getsym(argv);
}
}
break;
case A_LONG:
{
long l = atom_getlong(argv);
char buf[128];
sprintf(buf, "/%ld", l);
x->prefix = gensym(buf);
}
break;
default:
object_error((t_object *)x, "prefix value must be an integer or a string");
return MAX_ERR_GENERIC;
}
return MAX_ERR_NONE;
}
t_pd_err vectors_set(t_hoa_meter *x, void *attr, long argc, t_atom *argv)
{
if(argc && argv)
{
if(atom_gettype(argv) == A_SYM)
{
if(atom_getsym(argv) == hoa_sym_energy)
x->f_vector_type = hoa_sym_energy;
else if(atom_getsym(argv) == hoa_sym_velocity)
x->f_vector_type = hoa_sym_velocity;
else if(atom_getsym(argv) == hoa_sym_both)
x->f_vector_type = hoa_sym_both;
else
x->f_vector_type = hoa_sym_none;
}
else if(atom_gettype(argv) == A_FLOAT)
{
if(atom_getlong(argv) == 1)
x->f_vector_type = hoa_sym_energy;
else if(atom_getlong(argv) == 2)
x->f_vector_type = hoa_sym_velocity;
else if(atom_getlong(argv) == 3)
x->f_vector_type = hoa_sym_both;
else
x->f_vector_type = hoa_sym_none;
}
ebox_invalidate_layer((t_ebox *)x, hoa_sym_vector_layer);
}
return 0;
}
void kernelmaker_ring_mod (t_kernelmaker *x, t_symbol *msg, long argc, t_atom *argv)
{
if (argc < 4)
error ("kernelmaker~: not enough argments to message makekernel_ring");
kernelmaker_ring_mod_internal(x, atom_getsym(argv + 0), atom_getsym(argv + 1), atom_getsym(argv + 2), atom_getlong(argv + 3));
}
void *hoa_optim_new(t_symbol *s, long argc, t_atom *argv)
{
t_hoa_optim *x = NULL;
int order = 1;
x = (t_hoa_optim *)object_alloc(hoa_optim_class);
if (x)
{
if(atom_gettype(argv) == A_LONG)
order = atom_getlong(argv);
x->f_optim = new Hoa3D::Optim(order, Hoa3D::Optim::InPhase);
if(argc > 1 && atom_gettype(argv+1) == A_SYM)
{
if(atom_getsym(argv+1) == gensym("maxRe"))
x->f_optim->setMode(Hoa3D::Optim::MaxRe);
else if(atom_getsym(argv+1) == gensym("basic"))
x->f_optim->setMode(Hoa3D::Optim::Basic);
}
dsp_setup((t_pxobject *)x, x->f_optim->getNumberOfHarmonics());
for (int i = 0; i < x->f_optim->getNumberOfHarmonics(); i++)
outlet_new(x, "signal");
x->f_signals = new double[x->f_optim->getNumberOfHarmonics() * SYS_MAXBLKSIZE];
}
return (x);
}
void hoa_map_3D_tilde_list(t_hoa_map_3D_tilde *x, t_symbol* s, long argc, t_atom* argv)
{
if(argc > 2 && argv && atom_gettype(argv) == A_LONG && atom_gettype(argv+1) == A_SYM)
{
int index = atom_getlong(argv);
if(index < 1 || index > x->f_map->getNumberOfSources())
return;
if(argc > 4 && (atom_getsym(argv+1) == hoa_sym_polar || atom_getsym(argv+1) == hoa_sym_pol))
{
x->f_lines->setRadius(index-1, atom_getfloat(argv+2));
x->f_lines->setAzimuth(index-1, atom_getfloat(argv+3));
x->f_lines->setElevation(index-1, atom_getfloat(argv+4));
}
else if(argc > 4 && (atom_getsym(argv+1) == hoa_sym_cartesian || atom_getsym(argv+1) == hoa_sym_car))
{
x->f_lines->setRadius(index-1, radius(atom_getfloat(argv+2), atom_getfloat(argv+3), atom_getfloat(argv+4)));
x->f_lines->setAzimuth(index-1, azimuth(atom_getfloat(argv+2), atom_getfloat(argv+3), atom_getfloat(argv+4)));
x->f_lines->setElevation(index-1, elevation(atom_getfloat(argv+2), atom_getfloat(argv+3), atom_getfloat(argv+4)));
}
else if(argc > 2 && atom_getsym(argv+1) == hoa_sym_mute)
{
x->f_map->setMute(index-1, atom_getlong(argv+2));
}
}
}
void kernelmaker_env (t_kernelmaker *x, t_symbol *msg, long argc, t_atom *argv)
{
if (argc < 5)
error ("kernelmaker~: not enough argments to message makekernel_env");
kernelmaker_env_internal(x, atom_getsym(argv + 0), atom_getsym(argv + 1), atom_getsym(argv + 2), atom_getlong(argv + 3), atom_getlong(argv + 4));
}
void *hoa_recomposer_new(t_symbol *s, long argc, t_atom *argv)
{
t_hoa_recomposer *x = NULL;
int order = 4;
int microphones = 10;
int mode = Hoa_Fixe;
x = (t_hoa_recomposer *)eobj_new(hoa_recomposer_class);
order = atom_getint(argv);
microphones = atom_getint(argv+1);
if (atom_gettype(argv+2) == A_SYM)
{
if(atom_getsym(argv+2) == gensym("fixe"))
mode = Hoa_Fixe;
else if(atom_getsym(argv+2) == gensym("fisheye"))
mode = Hoa_Fisheye;
else if(atom_getsym(argv+2) == gensym("free"))
mode = Hoa_Free;
}
if (atom_gettype(argv+2) == A_LONG)
{
mode = Tools::clip(long(atom_getlong(argv+2)), 0, 2);
}
x->f_ambi_recomposer = new AmbisonicRecomposer(order, microphones, mode, sys_getblksize(), sys_getsr());
eobj_dspsetup(x, x->f_ambi_recomposer->getNumberOfInputs(), x->f_ambi_recomposer->getNumberOfOutputs());
x->f_ob.d_misc = E_NO_INPLACE;
return (x);
}
// Return values to the hub (so it can return them to the outside world)
void return_send_feedback(t_return *x)
{
if (x->common.hub != NULL) {
if (x->common.has_wildcard)
object_method_typed(x->common.hub, jps_return_extended, x->output_len, x->output, NULL);
else
object_method_typed(x->common.hub, jps_return, x->output_len, x->output, NULL);
}
if (x->send) {
if (x->output_len > 2) {
if (x->output[1].a_type == A_FLOAT || x->output[1].a_type == A_LONG)
object_method_typed(x->send, _sym_list, x->output_len-1, x->output+1, NULL);
else
object_method_typed(x->send, atom_getsym(x->output), x->output_len-1, x->output+1, NULL);
}
else if (x->output_len > 1) {
if (x->output[1].a_type == A_FLOAT)
object_method_typed(x->send, _sym_float, x->output_len-1, x->output+1, NULL);
else if (x->output[1].a_type == A_LONG)
object_method_typed(x->send, _sym_int, x->output_len-1, x->output+1, NULL);
else
object_method_typed(x->send, atom_getsym(x->output), 0, NULL, NULL);
}
else
object_method_typed(x->send, _sym_bang, 0, NULL, NULL);
}
x->output_len = 1; // truncate to just the name of this jcom.return object
}
t_max_err mode_set(t_hoa_decoder *x, t_object *attr, long argc, t_atom *argv)
{
if(argc && argv && atom_gettype(argv) == A_SYM)
{
if(atom_getsym(argv) == gensym("ambisonic") && x->f_decoder->getDecodingMode() != Hoa2D::DecoderMulti::Regular)
{
object_method(gensym("dsp")->s_thing, gensym("stop"));
x->f_decoder->setDecodingMode(Hoa2D::DecoderMulti::Regular);
object_attr_setdisabled((t_object *)x, gensym("angles"), 1);
object_attr_setdisabled((t_object *)x, gensym("channels"), 0);
object_attr_setdisabled((t_object *)x, gensym("offset"), 0);
object_attr_setfloat(x, gensym("offset"), (float)x->f_decoder->getChannelsOffset() / HOA_2PI * 360.f);
}
else if(atom_getsym(argv) == gensym("irregular") && x->f_decoder->getDecodingMode() != Hoa2D::DecoderMulti::Irregular)
{
object_method(gensym("dsp")->s_thing, gensym("stop"));
x->f_decoder->setDecodingMode(Hoa2D::DecoderMulti::Irregular);
object_attr_setdisabled((t_object *)x, gensym("angles"), 0);
object_attr_setdisabled((t_object *)x, gensym("channels"), 0);
object_attr_setdisabled((t_object *)x, gensym("offset"), 1);
}
else if(atom_getsym(argv) == gensym("binaural") && x->f_decoder->getDecodingMode() != Hoa2D::DecoderMulti::Binaural)
{
object_method(gensym("dsp")->s_thing, gensym("stop"));
x->f_decoder->setDecodingMode(Hoa2D::DecoderMulti::Binaural);
object_attr_setdisabled((t_object *)x, gensym("angles"), 1);
object_attr_setdisabled((t_object *)x, gensym("channels"), 1);
object_attr_setdisabled((t_object *)x, gensym("offset"), 1);
}
object_attr_setlong(x, gensym("channels"), x->f_decoder->getNumberOfChannels());
}
send_configuration(x);
return MAX_ERR_NONE;
}
/**
Look ahead function to test whether a dictionary matches a condition
*/
t_bool _dict_recurse_match_dict(t_dict_recurse *x, t_dictionary *dict, t_symbol **key_match, t_symbol **value_match)
{
TRACE("_dict_recurse_match_dict");
// Get the dictionary keys
long key_cnt = 0;
t_symbol **key_arr = NULL;
t_symbol *key = gensym("");
t_atom value[1];
*key_match = gensym("");
*value_match = gensym("");
dictionary_getkeys(dict, &key_cnt, &key_arr);
t_bool test = false;
for (t_int32 ind = 0; ind < key_cnt; ind++) {
key = key_arr[ind];
if (!regexpr_match(x->search_key_expr, key)) { continue; }
dictionary_getatom(dict, key, value);
if (regexpr_match(x->search_val_expr, atom_getsym(value))) {
test = true;
*key_match = key;
*value_match = atom_getsym(value);
break; } }
if (key_arr) { dictionary_freekeys(dict, key_cnt, key_arr); }
return test;
}
void ramp_setFunctionParameter(t_ramp *obj, t_symbol *msg, long argc, t_atom *argv)
{
TTSymbol* parameterName;
TTValue newValue;
int i;
TTValue v;
if (argc < 2) {
error("jcom.map: not enough arguments to setParameter");
return;
}
// get the correct TT name for the parameter given the Max name
parameterName = TT(atom_getsym(argv)->s_name);
obj->parameterNames->lookup(parameterName, v);
v.get(0, ¶meterName);
for (i=1; i<=(argc-1); i++) {
if (argv[i].a_type == A_SYM)
newValue.append(TT(atom_getsym(argv+1)->s_name));
else
newValue.append(atom_getfloat(argv+i));
}
obj->rampUnit->setFunctionParameterValue(parameterName, newValue);
}
t_max_err pinna_set(t_hoa_decoder *x, t_object *attr, long argc, t_atom *argv)
{
if(argc && argv && atom_gettype(argv) == A_SYM)
{
if(atom_getsym(argv) == gensym("small") /* && x->f_decoder->getPinnaSize() != Hoa2D::DecoderBinaural::Small*/)
{
/*
if(x->f_decoder->getDecodingMode() == Hoa3D::DecoderMulti::Binaural)
object_method(gensym("dsp")->s_thing, hoa_sym_stop);
x->f_decoder->setPinnaSize(Hoa3D::DecoderBinaural::Small);
*/
x->f_pinna = atom_getsym(argv);
}
else if(atom_getsym(argv) == gensym("large") /* && x->f_decoder->getPinnaSize() != Hoa3D::DecoderBinaural::Large */)
{
/*
if(x->f_decoder->getDecodingMode() == Hoa2D::DecoderMulti::Binaural)
object_method(gensym("dsp")->s_thing, hoa_sym_stop);
x->f_decoder->setPinnaSize(Hoa3D::DecoderBinaural::Large);
*/
x->f_pinna = atom_getsym(argv);
}
}
return MAX_ERR_NONE;
}
void irphase_userphase (t_irphase *x, t_symbol *sym, long argc, t_atom *argv)
{
t_symbol *target;
t_symbol *source;
double phase;
double time_mul = 1.;
t_phase_type mode;
if ((sym != gensym("mixedphase") && argc < 2) || (sym == gensym("mixedphase") && argc < 3))
{
object_error((t_object *) x, "not enough arguments to message %s", sym->s_name);
return;
}
target = atom_getsym(argv++);
source = atom_getsym(argv++);
argc--;
argc--;
if (sym == gensym("minphase"))
{
mode = MODE_MINPHASE;
phase = 0.0;
}
if (sym == gensym("maxphase"))
{
mode = MODE_MAXPHASE;
phase = 1.0;
}
if (sym == gensym("linphase"))
{
mode = MODE_LINPHASE;
phase = 0.5;
}
if (sym == gensym("allpass"))
{
mode = MODE_ALLPASS;
phase = 0.0;
}
if (sym == gensym("mixedphase"))
{
mode = MODE_MIXEDPHASE;
phase = atom_getfloat(argv++);
argc--;
}
if (argc)
{
time_mul = atom_getfloat(argv++);
argc--;
}
irphase_process(x, target, source, phase, time_mul, mode);
}
void dict_recurse_test_match(t_dict_recurse *x, t_symbol *sym, long argc, t_atom *argv)
{
t_symbol *expr = atom_getsym(argv);
t_symbol *key_sym = atom_getsym(argv + 1);
regexpr_set(x->search_key_expr, expr);
regexpr_match(x->search_key_expr, key_sym);
regexpr_reset(x->search_key_expr);
}
void bufreverse_process_internal(t_bufreverse *x, t_symbol *sym, short argc, t_atom *argv)
{
t_symbol *target = atom_getsym(argv++);
t_symbol *source = atom_getsym(argv++);
float *temp1;
double *temp2;
t_buffer_write_error error;
AH_SIntPtr full_length = buffer_length(source);
AH_SIntPtr i;
double sample_rate = 0;
t_atom_long read_chan = x->read_chan - 1;
// Check source buffer
if (buffer_check((t_object *) x, source, read_chan))
return;
sample_rate = buffer_sample_rate(source);
// Allocate Memory
temp1 = (float *) ALIGNED_MALLOC(full_length * (sizeof(double) + sizeof(float)));
temp2 = (double *) (temp1 + full_length);
// Check momory allocation
if (!temp1)
{
object_error((t_object *)x, "could not allocate temporary memory for processing");
free(temp1);
return;
}
// Read from buffer
buffer_read(source, read_chan, (float *) temp1, full_length);
// Copy to double precision version
for (i = 0; i < full_length; i++)
temp2[i] = temp1[full_length - i - 1];
// Copy out to buffer
error = buffer_write(target, temp2, full_length, x->write_chan - 1, x->resize, sample_rate, 1.);
buffer_write_error((t_object *)x, target, error);
// Free Resources
ALIGNED_FREE(temp1);
if (!error)
outlet_bang(x->process_done);
}
void HoaTool_list(t_HoaTool *x, t_symbol *s, long argc, t_atom *argv)
{
if(atom_getsym(argv+1) == gensym("car") || atom_getsym(argv+1) == gensym("cartesian"))
x->f_AmbisonicPolyEase->setCartesianCoordinates(atom_getlong(argv), atom_getfloat(argv+2), atom_getfloat(argv+3));
else if(atom_getsym(argv+1) == gensym("pol") || atom_getsym(argv+1) == gensym("polar"))
x->f_AmbisonicPolyEase->setPolarCoordinates(atom_getlong(argv), atom_getfloat(argv+2), atom_getfloat(argv+3));
else if (atom_getsym(argv+1) == gensym("mute"))
x->f_AmbisonicPolyEase->setMuted(atom_getlong(argv), atom_getlong(argv+2));
}
void *hoa_map_3D_tilde_new(t_symbol *s, long argc, t_atom *argv)
{
t_hoa_map_3D_tilde *x = NULL;
t_binbuf *d;
int order = 1;
int numberOfSources = 1;
if (!(d = binbuf_via_atoms(argc,argv)))
return NULL;
x = (t_hoa_map_3D_tilde *)eobj_new(hoa_map_3D_tilde_class);
if (x)
{
if(atom_gettype(argv) == A_LONG)
order = clip_min(atom_getlong(argv), 0);
if(argc > 1 && atom_gettype(argv+1) == A_LONG)
numberOfSources = clip_minmax(atom_getlong(argv+1), 1, 255);
if(argc > 2 && atom_gettype(argv+2) == A_SYM)
{
if(atom_getsym(argv+2) == gensym("car") || atom_getsym(argv+2) == gensym("cartesian"))
x->f_mode = 1;
else
x->f_mode = 0;
}
else
x->f_mode = 0;
x->f_ramp = 100;
x->f_map = new Hoa3D::Map(order, numberOfSources);
x->f_lines = new MapPolarLines3D(x->f_map->getNumberOfSources());
x->f_lines->setRamp(0.1 * sys_getsr());
for (int i = 0; i < x->f_map->getNumberOfSources(); i++)
{
x->f_lines->setRadiusDirect(i, 1);
x->f_lines->setAzimuthDirect(i, 0.);
x->f_lines->setElevationDirect(i, 0.);
}
if(x->f_map->getNumberOfSources() == 1)
eobj_dspsetup(x, 4, x->f_map->getNumberOfHarmonics());
else
eobj_dspsetup(x, x->f_map->getNumberOfSources(), x->f_map->getNumberOfHarmonics());
if(x->f_map->getNumberOfSources() == 1)
x->f_sig_ins = new t_float[4 * SYS_MAXBLKSIZE];
else
x->f_sig_ins = new t_float[x->f_map->getNumberOfSources() * SYS_MAXBLKSIZE];
x->f_sig_outs = new t_float[x->f_map->getNumberOfHarmonics() * SYS_MAXBLKSIZE];
x->f_lines_vector = new float[x->f_map->getNumberOfSources() * 3];
ebox_attrprocess_viabinbuf(x, d);
}
return (x);
}
void *oscroute_new(t_symbol *s, long argc, t_atom *argv)
{
short i;
t_oscroute *x = (t_oscroute *)object_alloc(oscroute_class);
if (x) {
x->outlet_overflow = outlet_new(x, 0); // overflow outlet
//object_obex_store((void *)x, _sym_dumpout, (object *)x->outlet_overflow); // dumpout
x->num_args = argc;
if (argc < 1) { // if no args are provided, we provide a way to set the arg using an inlet
x->num_args = 1;
x->arguments[0] = gensym("/nil");
x->arglen[0] = 4;
x->proxy_inlet = proxy_new(x, 1, 0L);
x->outlets[0] = outlet_new(x, 0);
}
else {
x->proxy_inlet = 0;
for (i=x->num_args-1; i >= 0; i--) {
x->outlets[i] = outlet_new(x, 0); // Create Outlet
switch(argv[i].a_type) {
case A_SYM:
//atom_setsym(&(x->arguments[i]), atom_getsym(argv+i));
x->arguments[i] = atom_getsym(argv+i);
x->arglen[i] = strlen(atom_getsym(argv+i)->s_name);
break;
case A_LONG:
{
char tempstr[256];
snprintf(tempstr, 256, "%ld", atom_getlong(argv+i));
x->arguments[i] = gensym(tempstr);
x->arglen[i] = strlen(tempstr);
}
break;
case A_FLOAT:
{
char tempstr[256];
snprintf(tempstr, 256, "%f", atom_getfloat(argv+i));
x->arguments[i] = gensym(tempstr);
x->arglen[i] = strlen(tempstr);
}
break;
default:
error("jcom.oscroute - invalid arguments - all args must be symbols");
}
}
}
//attr_args_process(x, argc, argv); //handle attribute args
}
return (x); // return the pointer to our new instantiation
}
void dict_re_simulate(t_dict_recurse *x, t_symbol *sym, long argc, t_atom *argv)
{
TRACE("dict_re_simulate");
t_bool test = re_simulate(x->re2, atom_getsym(argv)->s_name);
MY_ASSERT(x->re2->err != ERR_NONE, "Simulation error.");
POST("Search: %s - Match: %s%s%s - %s", x->re2->re_search_s, atom_getsym(argv)->s_name,
(x->re2->repl_sub_cnt) ? " - Replace: " : "", (x->re2->repl_sub_cnt) ? x->re2->replace_p : "",
test ? "MATCH" : "NO MATCH");
}
int cmmjl_osc_copy_max_messages(t_symbol *msg, short argc, t_atom *argv, int len, char *buf){
int pos = 0;
int n = strlen(msg->s_name);
int i;
memcpy(buf + pos, msg->s_name, n);
pos += n + 1;
while(pos % 4){
pos++;
}
n = argc;
buf[pos++] = ',';
for(i = 0; i < argc; i++){
switch(argv[i].a_type){
case A_FLOAT:
buf[pos++] = 'f';
break;
case A_LONG:
buf[pos++] = 'i';
break;
case A_SYM:
buf[pos++] = 's';
break;
}
}
pos++;
while(pos % 4){
pos++;
}
for(i = 0; i < argc; i++){
switch(argv[i].a_type){
case A_FLOAT:
{
float f = atom_getfloat(argv + i);
*((long *)(buf + pos)) = htonl(*(long *)(&f));
pos += 4;
}
break;
case A_LONG:
*((long *)(buf + pos)) = htonl(atom_getlong(argv + i));
pos += 4;
break;
case A_SYM:
n = strlen(atom_getsym(argv + i)->s_name);
memcpy(buf + pos, atom_getsym(argv + i)->s_name, n);
pos += n + 1;
while(pos % 4){
pos++;
}
break;
}
}
return pos;
}
t_pd_err atoms_get_attribute(long ac, t_atom* av, t_symbol *key, long *argc, t_atom **argv)
{
int i = 0, index = 0;
argc[0] = 0;
argv[0] = NULL;
if(ac && av)
{
for(i = 0; i < ac; i++)
{
if(atom_gettype(av+i) == A_SYM && atom_getsym(av+i) == key)
{
index = i + 1;
break;
}
}
}
if(index)
{
i = index;
while (i < ac && atom_getsym(av+i)->s_name[0] != '@')
{
i++;
argc[0]++;
}
}
else
{
argc[0] = 0;
argv[0] = NULL;
return -1;
}
if(argc[0])
{
argv[0] = (t_atom *)calloc(argc[0], sizeof(t_atom));
for (i = 0; i < argc[0]; i++)
{
argv[0][i] = av[i+index];
}
argc[0] = atoms_from_fatoms(argc[0], argv[0]);
}
else
{
argc[0] = 0;
argv[0] = NULL;
return -1;
}
return 0;
}
void dict_re_compile(t_dict_recurse *x, t_symbol *sym, long argc, t_atom *argv)
{
TRACE("dict_re_compile");
if (argc == 1) { re_compile(x->re2, atom_getsym(argv)->s_name, NULL); }
else if (argc == 2) { re_compile(x->re2, atom_getsym(argv)->s_name, atom_getsym(argv + 1)->s_name); }
MY_ASSERT(x->re2->err != ERR_NONE, "Compilation error.");
POST("Compile: %s %s - RPN: %s - States: %i - Flags: %i - Substr: %i %s",
x->re2->re_search_s, atom_getsym(argv + 1)->s_name, x->re2->rpn_s, x->re2->state_cnt,
x->re2->capt_flags, x->re2->repl_sub_cnt, x->re2->repl_sub_s);
}
/* Binaural */
t_max_err pinnaesize_set(t_HoaDecode *x, t_object *attr, long argc, t_atom *argv)
{
if(atom_gettype(argv) == A_SYM && (atom_getsym(argv) == gensym("large") || atom_getsym(argv) == gensym("Large")))
x->f_AmbisonicsDecoder->setPinnaeSize(Hoa_Large);
else
x->f_AmbisonicsDecoder->setPinnaeSize(Hoa_Small);
if(x->f_AmbisonicsDecoder->getPinnaeSize() == Hoa_Large)
x->f_pinna_size = gensym("large");
else
x->f_pinna_size = gensym("small");
return NULL;
}
/* Irregular */
t_max_err restitution_set(t_HoaDecode *x, t_object *attr, long argc, t_atom *argv)
{
if(atom_getsym(argv) == gensym("projection") || atom_getsym(argv) == gensym("Projection"))
x->f_AmbisonicsDecoder->setRestitutionMode(Hoa_Microphone_Simulation);
else
x->f_AmbisonicsDecoder->setRestitutionMode(Hoa_Amplitude_Panning);
if(x->f_AmbisonicsDecoder->getRestitutionMode() == Hoa_Microphone_Simulation)
x->f_resitution_mode = gensym("projection");
else
x->f_resitution_mode = gensym("panning");
return NULL;
}
t_max_err configuration_set(t_HoaDecode *x, t_object *attr, long argc, t_atom *argv)
{
if(atom_gettype(argv) == A_SYM)
{
int dspState = sys_getdspobjdspstate((t_object*)x);
if(dspState)
object_method(gensym("dsp")->s_thing, gensym("stop"));
long numOutlet = x->f_AmbisonicsDecoder->getNumberOfOutputs();
if(atom_getsym(argv) == gensym("binaural") || atom_getsym(argv) == gensym(" binaural"))
{
x->f_AmbisonicsDecoder->setMode(Hoa_Dec_Binaural);
x->f_mode = gensym("binaural");
object_attr_setdisabled((t_object *)x, gensym("angles"), 1);
object_attr_setdisabled((t_object *)x, gensym("pinnaesize"), 0);
object_attr_setdisabled((t_object *)x, gensym("loudspeakers"), 1);
object_attr_setdisabled((t_object *)x, gensym("restitution"), 1);
}
else if(atom_getsym(argv) == gensym("irregular") || atom_getsym(argv) == gensym(" irregular"))
{
x->f_AmbisonicsDecoder->setMode(Hoa_Dec_Irregular);
x->f_mode = gensym("irregular");
object_attr_setdisabled((t_object *)x, gensym("angles"), 0);
object_attr_setdisabled((t_object *)x, gensym("pinnaesize"), 1);
object_attr_setdisabled((t_object *)x, gensym("loudspeakers"), 0);
object_attr_setdisabled((t_object *)x, gensym("restitution"), 0);
}
else
{
x->f_AmbisonicsDecoder->setMode(Hoa_Dec_Ambisonic);
x->f_mode = gensym("ambisonic");
object_attr_setdisabled((t_object *)x, gensym("angles"), 1);
object_attr_setdisabled((t_object *)x, gensym("pinnaesize"), 1);
object_attr_setdisabled((t_object *)x, gensym("loudspeakers"), 0);
object_attr_setdisabled((t_object *)x, gensym("restitution"), 1);
}
HoaDecode_resize_outlet(x, numOutlet);
x->f_number_of_loudspeakers = x->f_AmbisonicsDecoder->getNumberOfOutputs();
for(int i = 0; i < x->f_number_of_loudspeakers; i++)
x->f_angles_of_loudspeakers[i] = x->f_AmbisonicsDecoder->getLoudspeakerAngle(i);
object_attr_touch((t_object *)x, gensym("loudspeakers"));
object_attr_touch((t_object *)x, gensym("angles"));
}
return NULL;
}
void hoa_optim_deprecated(t_hoa_optim* x, t_symbol *s, long ac, t_atom* av)
{
t_atom* argv;
long argc;
if(s && s == gensym("mode") && ac && av)
{
if(atom_gettype(av) == A_SYM)
{
if(atom_getsym(av) == gensym("maxRe"))
x->f_optim->setMode(Hoa2D::Optim::MaxRe);
else if(atom_getsym(av) == gensym("basic"))
x->f_optim->setMode(Hoa2D::Optim::Basic);
else
x->f_optim->setMode(Hoa2D::Optim::InPhase);
}
else
{
if(atom_getlong(av) == 1)
x->f_optim->setMode(Hoa2D::Optim::MaxRe);
else if(atom_getlong(av) == 0)
x->f_optim->setMode(Hoa2D::Optim::Basic);
else
x->f_optim->setMode(Hoa2D::Optim::InPhase);
}
object_error(x, "%s attribute @mode is deprecated, please use it as an argument.", eobj_getclassname(x)->s_name);
}
atoms_get_attribute(ac, av, gensym("@mode"), &argc, &argv);
if(argc && argv)
{
if(atom_gettype(argv) == A_SYM)
{
if(atom_getsym(argv) == gensym("maxRe"))
x->f_optim->setMode(Hoa2D::Optim::MaxRe);
else if(atom_getsym(argv) == gensym("basic"))
x->f_optim->setMode(Hoa2D::Optim::Basic);
else
x->f_optim->setMode(Hoa2D::Optim::InPhase);
}
else
{
if(atom_getlong(argv) == 1)
x->f_optim->setMode(Hoa2D::Optim::MaxRe);
else if(atom_getlong(argv) == 0)
x->f_optim->setMode(Hoa2D::Optim::Basic);
else
x->f_optim->setMode(Hoa2D::Optim::InPhase);
}
object_error(x, "%s attribute @mode is deprecated, please use it as an argument.", eobj_getclassname(x)->s_name);
argc = 0;free(argv);argv = NULL;
}
}
void outlet_atomlist(void *out, long argc, t_atom *argv)
{
if (argc == 1) {
if (atom_gettype(argv) == A_LONG)
outlet_int(out,atom_getlong(argv));
else if (atom_gettype(argv) == A_FLOAT)
outlet_float(out,atom_getfloat(argv));
else if (atom_gettype(argv) == A_SYM)
outlet_anything(out,atom_getsym(argv),0,0);
} else if (atom_gettype(argv) == A_FLOAT || atom_gettype(argv) == A_LONG)
outlet_list(out,ps_list,argc,argv);
else if (atom_gettype(argv) == A_SYM)
outlet_anything(out,atom_getsym(argv),argc-1,argv+1);
}
void breakpoints_write(t_breakpoints *x, t_symbol *s, int argc, t_atom *argv)
{
t_binbuf *d = binbuf_new();
if(d && argv && argc && atom_gettype(argv) == A_SYM)
{
breakpoints_save(x, d);
if(binbuf_write(d, atom_getsym(argv)->s_name, "", 0))
{
object_error(x, "breakpoints : %s write failed", atom_getsym(argv)->s_name);
}
}
if(d)
binbuf_free(d);
}
void *euclid_new(t_symbol *s, long argc, t_atom *argv)
{
t_euclid *x = NULL;
long i;
// object instantiation, NEW STYLE
if (x = (t_euclid *)object_alloc(euclid_class)) {
object_post((t_object *)x, "a new %s object was instantiated: 0x%X", s->s_name, x);
object_post((t_object *)x, "it has %ld arguments", argc);
x = (t_euclid *)object_alloc(euclid_class);
x->m_outlet1 = listout((t_euclid *)x);
for (i = 0; i < argc; i++) {
if ((argv + i)->a_type == A_LONG) {
object_post((t_object *)x, "arg %ld: long (%ld)", i, atom_getlong(argv+i));
} else if ((argv + i)->a_type == A_FLOAT) {
object_post((t_object *)x, "arg %ld: float (%f)", i, atom_getfloat(argv+i));
} else if ((argv + i)->a_type == A_SYM) {
object_post((t_object *)x, "arg %ld: symbol (%s)", i, atom_getsym(argv+i)->s_name);
} else {
object_error((t_object *)x, "forbidden argument");
}
}
}
// default values
x->l_M = 12;
x->l_N = 5;
x->l_rotate = 0;
return (x);
}
