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); }