/**************************************************************** * Constructor */ void *strstr_new(t_symbol *sym, long argc, t_atom *argv) { t_strstr *x = NULL; x = (t_strstr *)object_alloc(strstr_class); if (x == NULL) { error("strstr: Allocation failed."); return NULL; } // Set inlets, outlets, and proxy x->inl_proxy_ind = 0; x->inl_proxy = proxy_new((t_object *)x, 1, &x->inl_proxy_ind); x->outl_int = intout((t_object *)x); // Set the left string buffer x->i_dstr1 = dstr_new(); // First argument: right string buffer x->i_dstr2 = dstr_new(); if ((argc >= 1) && (attr_args_offset((short)argc, argv) >= 1)) { x->i_dstr2 = str_cat_atom(x, x->i_dstr2, argv); } // Test the string buffers if (DSTR_IS_NULL(x->i_dstr1) || DSTR_IS_NULL(x->i_dstr2)) { object_error((t_object *)x, "Allocation error."); strstr_free(x); return NULL; } // Second argument: mode long mode = 0; if ((argc >= 2) && (attr_args_offset((short)argc, argv) >= 2)) { if ((atom_gettype(argv + 1) == A_LONG) && (atom_getlong(argv + 1) >= 0) && (atom_getlong(argv + 1) <= 1)) { mode = (long)atom_getlong(argv + 1); } else { object_error((t_object *)x, "Arg 2: Mode: 0 or 1 expected"); } } object_attr_setlong(x, gensym("mode"), mode); // Set the float precision object_attr_setlong(x, gensym("fprecision"), 6); // Set the remaining variables x->o_pos = -1; // Process the attributes attr_args_process(x, (short)argc, argv); return x; }
// Create void *receive_new(t_symbol *s, long argc, t_atom *argv) { long attrstart = attr_args_offset(argc, argv); // support normal arguments t_receive *x = (t_receive *)object_alloc(s_receive_class); if (x) { object_obex_store((void *)x, _sym_dumpout, (object *)outlet_new(x, NULL)); x->outlet = outlet_new(x, NULL); if (!g_receivemaster_object) g_receivemaster_object = (t_object *)object_new_typed(CLASS_NOBOX, SymbolGen("jcom.receivemaster"), 0, NULL); x->callback = NULL; x->attr_name = NULL; // attr_args_process(x, argc, argv); // handle attribute args // If no name was specified as an attribute if (x->attr_name == NULL) { if (attrstart > 0) x->attr_name = atom_getsym(argv); else x->attr_name = SymbolGen("jcom.receive no arg specified"); receive_bind(x); } } return x; }
// Create void *fade_new(t_symbol *s, long argc, t_atom *argv) { long attrstart = attr_args_offset(argc, argv); // support normal arguments short i; t_fade *x = (t_fade *)object_alloc(s_fade_class); if(x){ object_obex_store((void *)x, _sym_dumpout, (object *)outlet_new(x, NULL)); // dumpout x->numChannels = 1; if(attrstart && argv){ int argument = atom_getlong(argv); x->numChannels = TTClip(argument, 1, MAX_NUM_CHANNELS); } dsp_setup((t_pxobject *)x, (x->numChannels * 2) + 1); // Create Object and N Inlets (last argument) x->x_obj.z_misc = Z_NO_INPLACE; // ESSENTIAL! for(i=0; i< (x->numChannels); i++) outlet_new((t_pxobject *)x, "signal"); // Create a signal Outlet //x->xfade = new TTCrossfade(x->numChannels); // Constructors TTObjectBaseInstantiate(TT("crossfade"), &x->xfade, x->numChannels); TTObjectBaseInstantiate(kTTSym_audiosignal, &x->audioIn1, x->numChannels); TTObjectBaseInstantiate(kTTSym_audiosignal, &x->audioIn2, x->numChannels); TTObjectBaseInstantiate(kTTSym_audiosignal, &x->audioInControl, x->numChannels); TTObjectBaseInstantiate(kTTSym_audiosignal, &x->audioOut, x->numChannels); x->xfade->setAttributeValue(TT("mode"), TT("lookup")); x->xfade->setAttributeValue(TT("shape"), TT("equalPower")); x->xfade->setAttributeValue(TT("position"), 0.5); attr_args_process(x, argc, argv); // handle attribute args } return (x); // Return the pointer }
void* op_new(t_symbol *msg, short argc, t_atom *argv) { t_op *x; TTValue sr(sys_getsr()); long attrstart = attr_args_offset(argc, argv); // support normal arguments short i; x = (t_op *)object_alloc(s_op_class); if(x){ x->maxNumChannels = 2; // An initial argument to this object will set the maximum number of channels if(attrstart && argv) x->maxNumChannels = atom_getlong(argv); ttEnvironment->setAttributeValue(kTTSym_sampleRate, sr); TTObjectBaseInstantiate(TT("operator"), &x->op, x->maxNumChannels); TTObjectBaseInstantiate(TT("audiosignal"), &x->audioIn, x->maxNumChannels); TTObjectBaseInstantiate(TT("audiosignal"), &x->audioOut, x->maxNumChannels); attr_args_process(x,argc,argv); // handle attribute args object_obex_store((void *)x, _sym_dumpout, (object *)outlet_new(x,NULL)); // dumpout dsp_setup((t_pxobject *)x, x->maxNumChannels); // inlets for(i=0; i < x->maxNumChannels; i++) outlet_new((t_pxobject *)x, "signal"); // outlets x->obj.z_misc = Z_NO_INPLACE; } return (x); // Return the pointer }
// Create void *init_new(t_symbol *s, long argc, t_atom *argv) { long attrstart = attr_args_offset(argc, argv); // support normal arguments t_init *x = (t_init *)object_alloc(g_init_class); t_symbol *relativeAddress = _sym_nothing; // could be used to binds on a sub level j.hub if (attrstart && argv) atom_arg_getsym(&relativeAddress, 0, attrstart, argv); if (x) { x->outlets = (TTHandle)sysmem_newptr(sizeof(TTPtr) * 2); x->outlets[end_out] = bangout(x); x->outlets[start_out] = bangout(x); x->patcherNode = NULL; x->address = TTAddress(jamoma_parse_dieze((t_object*)x, relativeAddress)->s_name); attr_args_process(x, argc, argv); // handle attribute args // The following must be deferred because we have to interrogate our box, // and our box is not yet valid until we have finished instantiating the object. // Trying to use a loadbang method instead is also not fully successful (as of Max 5.0.6) defer_low((t_object*)x, (method)init_subscribe, NULL, 0, 0); } return (x); // Return the pointer }
void *radians_new(t_symbol *msg, short argc, t_atom *argv) { t_atom_long myArg = 0; long attrstart; t_radians *x; attrstart = attr_args_offset(argc, argv); if(attrstart && argv) atom_arg_getlong(&myArg, 0, attrstart, argv); // support a normal int argument for bwc x = (t_radians *)object_alloc(radians_class);; if(x){ object_obex_store((void *)x, _sym_dumpout, (object *)outlet_new(x,NULL)); // dumpout dsp_setup((t_pxobject *)x,1); x->radians_out = floatout(x); // Create a floating-point Outlet outlet_new((t_object *)x, "signal"); x->tt = new tt_audio_base; // Create object for performing radian conversions x->tt->set_sr(sys_getsr()); x->radians_mode = myArg; // default mode attr_args_process(x, argc, argv); //handle attribute args } return (x); }
void WrappedMapperClass_new(TTPtr self, long argc, t_atom *argv) { WrappedModularInstancePtr x = (WrappedModularInstancePtr)self; t_symbol *relativeAddress; long attrstart = attr_args_offset(argc, argv); // support normal arguments // possible relativeAddress if (attrstart && argv) relativeAddress = atom_getsym(argv); else relativeAddress = _sym_nothing; if (relativeAddress) x->address = TTAddress(relativeAddress->s_name); jamoma_mapper_create((t_object*)x, x->wrappedObject); // Make two outlets x->outlets = (TTHandle)sysmem_newptr(sizeof(TTPtr)); x->outlets[data_out] = outlet_new((t_object*)x, NULL); // anything outlet to output data x->dumpOut = outlet_new((t_object*)x, NULL); // handle attribute args attr_args_process(x, argc, argv); // Prepare extra data x->extra = (t_extra*)malloc(sizeof(t_extra)); EXTRA->arguments = new TTValue(); jamoma_ttvalue_from_Atom(*EXTRA->arguments, _sym_nothing, argc, argv); // The following must be deferred because we have to interrogate our box, // and our box is not yet valid until we have finished instantiating the object. // Trying to use a loadbang method instead is also not fully successful (as of Max 5.0.6) // map_subscribe(x); // defer_low((t_object*)x, (method)map_subscribe, NULL, 0, 0); }
void *dpoltocar_new(t_symbol *s, short ac, t_atom *av) { t_dpoltocar *x; x = (t_dpoltocar *)object_alloc(dpoltocar_class); if(x) { x->d_outlet = listout(x); t_ptr_size attrstart = attr_args_offset(ac, av); // support normal arguments if((attrstart != 0) && (av)) { int argument = atom_getlong(&av[0]); if(argument == 0){ x->d_mode = 0; }else{ x->d_mode = 1; } } object_attr_setlong(x, gensym("mode"), x->d_mode); attr_args_process(x, ac, av); x->d_operational[0]=0; x->d_operational[1]=0; x->d_operational[2]=0; } return x; }
UnpackPtr UnpackNew(SymbolPtr msg, AtomCount argc, AtomPtr argv) { UnpackPtr self; TTValue sr(sys_getsr()); long attrstart = attr_args_offset(argc, argv); // support normal arguments short i; TTValue v; TTErr err; self = UnpackPtr(object_alloc(sUnpackClass)); if (self) { self->maxNumChannels = 2; // An initial argument to this object will set the maximum number of channels if(attrstart && argv) self->maxNumChannels = atom_getlong(argv); ttEnvironment->setAttributeValue(kTTSym_sampleRate, sr); v.setSize(2); v.set(0, TT("thru")); v.set(1, 1); // arg is the number of inlets err = TTObjectBaseInstantiate(TT("audio.object"), (TTObjectBasePtr*)&self->audioGraphObject, v); //self->audioGraphObject->getUnitGenerator()->setAttributeValue(TT("linearGain"), 1.0); attr_args_process(self, argc, argv); object_obex_store((void*)self, _sym_dumpout, (object*)outlet_new(self, NULL)); // dumpout dsp_setup((t_pxobject*)self, 1); for(i=0; i < self->maxNumChannels; i++) outlet_new((t_pxobject*)self, "signal"); self->qelem = qelem_new(self, (method)UnpackQFn); self->obj.z_misc = Z_NO_INPLACE | Z_PUT_LAST; } return self; }
void* balance_new(t_symbol *msg, short argc, t_atom *argv) { t_balance *x; TTValue sr(sys_getsr()); long attrstart = attr_args_offset(argc, argv); // support normal arguments short i; x = (t_balance *)object_alloc(balance_class); if(x){ // Default values x->attrFrequency = 10; x->attrBypass = 0; // An initial argument to this object will set the maximum number of channels to process // Two input channels are required for each processed channel (source and comperator) x->maxNumChannels = 1; if(attrstart && argv) x->maxNumChannels = atom_getlong(argv); ttEnvironment->setAttributeValue(kTTSym_SampleRate, sr); TTObjectInstantiate(TT("balance"), &x->balance, x->maxNumChannels); TTObjectInstantiate(TT("audiosignal"), &x->audioIn, x->maxNumChannels*2); TTObjectInstantiate(TT("audiosignal"), &x->audioOut, x->maxNumChannels); attr_args_process(x,argc,argv); // handle attribute args object_obex_store((void *)x, _sym_dumpout, (object *)outlet_new(x,NULL)); // dumpout dsp_setup((t_pxobject *)x, x->maxNumChannels*2); // inlets for(i=0; i < x->maxNumChannels; i++) outlet_new((t_pxobject *)x, "signal"); // outlets x->obj.z_misc = Z_NO_INPLACE; } return (x); // Return the pointer }
void *dict_route_new(t_symbol *s, long argc, t_atom *argv) { t_dict_route *x = (t_dict_route *)object_alloc(s_dict_route_class); long attrstart = attr_args_offset(argc, argv); t_dictionary *d = NULL; // dictionary with our 'prototype' specified by args to this object if (x) { x->outlet_nomatch = outlet_new(x, "dictionary"); x->outlet_dict = outlet_new(x, "dictionary"); x->inlet_tomatch = proxy_new(x, 1, &x->inletnum); if (attrstart) dictobj_dictionaryfromatoms(&d, attrstart, argv); if (!d) { char errorstring[256]; t_max_err err; err = dictobj_dictionaryfromstring(&d, "{ \"schema\" : \"*\" }", true, errorstring); if (err) error("dict.route: %s", errorstring); } x->schema_dict = dictobj_register(d, &x->schema_name); attr_args_process(x, argc, argv); } return x; }
ObjectPtr jamoma_new(SymbolPtr s, AtomCount argc, AtomPtr argv) { int attrstart = attr_args_offset(argc, argv); int i = 0; int channelCount = 2; SymbolPtr className = gensym("gain"); MaxAudioGraphWrappedClassPtr classWrapper = NULL; char maxClassName[256]; if (!attrstart) { error("must specify a jamoma class as the first argument"); return NULL; } while (attrstart--) { if (atom_gettype(argv+i) == A_LONG) channelCount = atom_getlong(argv+i); else if (atom_gettype(argv+i) == A_SYM) className = atom_getsym(argv+i); i++; } snprintf(maxClassName, 256, "j.%s=", className->s_name); if (!s_jamoma_class_hash) s_jamoma_class_hash = hashtab_new(0); hashtab_lookup(s_jamoma_class_hash, className, (t_object**)&classWrapper); if (!classWrapper) { wrapAsMaxAudioGraph(className->s_name, maxClassName, &classWrapper); hashtab_store(s_jamoma_class_hash, className, ObjectPtr(classWrapper)); } return MaxAudioGraphWrappedClass_new(gensym(maxClassName), argc-1, argv+1); }
// Create void *audiosend_new(t_symbol *s, long argc, t_atom *argv) { long attrstart = attr_args_offset(argc, argv); // support normal arguments t_audiosend *x = (t_audiosend *)object_alloc(s_audiosend_class); short i; if (x) { x->dumpout = outlet_new(x, NULL); object_obex_store(x, _sym_dumpout, (t_object *)x->dumpout); x->attr_target = _sym_nothing; x->num_inputs = 2; // TODO: make this dynamic from args for (i=0; i<attrstart; i++) { if (argv[i].a_type == A_LONG) x->num_inputs = atom_getlong(argv+i); else if (argv[i].a_type == A_SYM) x->attr_target = atom_getsym(argv+i); } dsp_setup((t_pxobject *)x, x->num_inputs); x->obj.z_misc = Z_NO_INPLACE; attr_args_process(x, argc, argv); // handle attribute args } return x; }
void WrappedInputClass_new(TTPtr self, AtomCount argc, AtomPtr argv) { WrappedModularInstancePtr x = (WrappedModularInstancePtr)self; long attrstart = attr_args_offset(argc, argv); // support normal arguments TTString sInstance; TTValue v; // Prepare extra data x->extra = (t_extra*)malloc(sizeof(t_extra)); // Get input instance symbol if (attrstart && argv) { jamoma_ttvalue_from_Atom(v, _sym_nothing, attrstart, argv); v.toString(); sInstance = TTString(v[0]); EXTRA->instance = TTSymbol(sInstance.data()); } else EXTRA->instance = kTTSymEmpty; // Create Input Object and one outlet x->outlets = (TTHandle)sysmem_newptr(sizeof(TTPtr)); #ifdef JCOM_IN_TILDE jamoma_input_create_audio((ObjectPtr)x, &x->wrappedObject); dsp_setup((t_pxobject *)x, 1); x->obj.z_misc = Z_NO_INPLACE | Z_PUT_FIRST; outlet_new((t_pxobject *)x, "signal"); // Prepare memory to store internal datas x->internals = new TTHash(); // Prepare extra data for envelope tracking EXTRA->clock = NULL; EXTRA->pollInterval = 0; // not active by default EXTRA->meter = 0.; EXTRA->peak = 0.; #else jamoma_input_create((ObjectPtr)x, &x->wrappedObject); x->outlets[0] = outlet_new(x, 0L); #endif // handle attribute args attr_args_process(x, argc, argv); // The following must be deferred because we have to interrogate our box, // and our box is not yet valid until we have finished instantiating the object. // Trying to use a loadbang method instead is also not fully successful (as of Max 5.0.6) defer_low((ObjectPtr)x, (method)in_subscribe, NULL, 0, NULL); }
// Create void *out_new(t_symbol *s, long argc, t_atom *argv) { long attrstart = attr_args_offset(argc, argv); // support normal arguments t_out *x = (t_out *)object_alloc(out_class); short i; if(x){ x->dumpout = outlet_new(x, NULL); object_obex_store((void *)x, jps_dumpout, (object *)x->dumpout); // setup the dumpout x->numOutputs = 1; x->attr_preview = 0; x->preview_object = NULL; x->attr_bypass = 0; x->attr_mute = 0; x->attr_mix = 100; // Assume 100%, so that processed signal is passed through if @has_mix is false if(attrstart > 0){ int argument = atom_getlong(argv); x->numOutputs = TTClip(argument, 1, MAX_NUM_CHANNELS); } #ifdef JCOM_OUT_TILDE if(x->numOutputs > 0) dsp_setup((t_pxobject *)x, x->numOutputs); // Create Object and Inlets else dsp_setup((t_pxobject *)x, 1); // Create Object and Inlets x->common.ob.z_misc = Z_NO_INPLACE | Z_PUT_LAST; // Z_PUT_LAST so that thispoly~ gets it's message properly? for(i=0; i < (x->numOutputs); i++) outlet_new((t_pxobject *)x, "signal"); // Create a signal Outlet x->clock = clock_new(x, (method)update_meters); x->clock_is_set = 0; TTObjectInstantiate(kTTSym_audiosignal, &x->audioIn, x->numOutputs); TTObjectInstantiate(kTTSym_audiosignal, &x->audioOut, x->numOutputs); TTObjectInstantiate(kTTSym_audiosignal, &x->audioTemp, x->numOutputs); TTObjectInstantiate(kTTSym_audiosignal, &x->zeroSignal, x->numOutputs); TTObjectInstantiate(TT("crossfade"), &x->xfade, x->numOutputs); x->xfade->setAttributeValue(TT("position"), 1.0); TTObjectInstantiate(TT("gain"), &x->gain, x->numOutputs); TTObjectInstantiate(TT("ramp"), &x->ramp_gain, x->numOutputs); TTObjectInstantiate(TT("ramp"), &x->ramp_xfade, x->numOutputs); // out_alloc(x, sys_getblksize()); // allocates the vectors for the audio signals x->gain->setAttributeValue(TT("linearGain"), 1.0); #else for(i=x->numOutputs-1; i >= 1; i--) x->inlet[i] = proxy_new(x, i, 0L); for(i=x->numOutputs-1; i >= 0; i--) x->outlet[i] = outlet_new(x, 0L); #endif jcom_core_subscriber_new_common(&x->common, jps__jcom_out__, jps_subscribe_out); jcom_core_subscriber_setcustomsubscribe_method(&x->common, &out_subscribe); attr_args_process(x, argc, argv); // handle attribute args jcom_core_subscriber_subscribe((t_jcom_core_subscriber_common*)x); } return (x); // Return the pointer }
void WrappedOutputClass_new(TTPtr self, long argc, t_atom* argv) { WrappedModularInstancePtr x = (WrappedModularInstancePtr)self; long attrstart = attr_args_offset(argc, argv); // support normal arguments TTString sInstance; TTValue v; // Prepare extra data x->extra = (t_extra*)malloc(sizeof(t_extra)); // Get input instance symbol if (attrstart && argv) { jamoma_ttvalue_from_Atom(v, _sym_nothing, attrstart, argv); v.toString(); sInstance = TTString(v[0]); EXTRA->instance = TTSymbol(sInstance.data()); } else EXTRA->instance = kTTSymEmpty; // Create Input Object and one outlet x->outlets = (TTHandle)sysmem_newptr(sizeof(TTPtr)); #ifdef J_OUT_TILDE jamoma_output_create_audio((t_object*)x, x->wrappedObject); dsp_setup((t_pxobject *)x, 1); x->obj.z_misc = Z_NO_INPLACE | Z_PUT_FIRST; outlet_new((t_pxobject *)x, "signal"); #endif #ifdef J_OUT_MULTI jamoma_output_create_audio((t_object*)x, x->wrappedObject); x->outlets[0] = outlet_new(x, 0L); #endif #ifndef J_OUT_TILDE #ifndef J_OUT_MULTI jamoma_output_create((t_object*)x, x->wrappedObject); x->outlets[0] = outlet_new((t_object*)x, 0L); #endif #endif // handle attribute args attr_args_process(x, argc, argv); // The following must be deferred because we have to interrogate our box, // and our box is not yet valid until we have finished instantiating the object. // Trying to use a loadbang method instead is also not fully successful (as of Max 5.0.6) // out_subscribe(x); // defer_low((t_object*)x, (method)out_subscribe, NULL, 0, NULL); }
ObjectPtr wrappedClass_new(SymbolPtr name, AtomCount argc, AtomPtr argv) { WrappedClass* wrappedMaxClass = NULL; WrappedInstancePtr self = NULL; TTValue v; TTErr err = kTTErrNone; TTUInt8 numInputs = 1; TTUInt8 numOutputs = 1; long attrstart = attr_args_offset(argc, argv); // support normal arguments // Find the WrappedClass hashtab_lookup(wrappedMaxClasses, name, (ObjectPtr*)&wrappedMaxClass); // If the WrappedClass has a validity check defined, then call the validity check function. // If it returns an error, then we won't instantiate the object. if (wrappedMaxClass) { if (wrappedMaxClass->validityCheck) err = wrappedMaxClass->validityCheck(wrappedMaxClass->validityCheckArgument); else err = kTTErrNone; } else err = kTTErrGeneric; if (!err) self = (WrappedInstancePtr)object_alloc(wrappedMaxClass->maxClass); if (self){ if (wrappedMaxClass->options && !wrappedMaxClass->options->lookup(TT("argumentDefinesNumInlets"), v)) { long argumentOffsetToDefineTheNumberOfInlets = v; if ((attrstart-argumentOffsetToDefineTheNumberOfInlets > 0) && argv+argumentOffsetToDefineTheNumberOfInlets) numInputs = atom_getlong(argv+argumentOffsetToDefineTheNumberOfInlets); } for (TTUInt16 i=numInputs-1; i>0; i--) self->inlets[i-1] = proxy_new(self, i, NULL); object_obex_store((void*)self, _sym_dumpout, (object*)outlet_new(self, NULL)); // dumpout if (wrappedMaxClass->options && !wrappedMaxClass->options->lookup(TT("argumentDefinesNumOutlets"), v)) { long argumentOffsetToDefineTheNumberOfOutlets = v; if ((attrstart-argumentOffsetToDefineTheNumberOfOutlets > 0) && argv+argumentOffsetToDefineTheNumberOfOutlets) numOutputs = atom_getlong(argv+argumentOffsetToDefineTheNumberOfOutlets); } for (TTInt16 i=numOutputs-1; i>=0; i--) self->audioGraphOutlets[i] = outlet_new(self, "audio.connect"); self->wrappedClassDefinition = wrappedMaxClass; v.setSize(3); v.set(0, wrappedMaxClass->ttClassName); v.set(1, numInputs); v.set(2, numOutputs); err = TTObjectInstantiate(TT("audio.object"), (TTObjectPtr*)&self->audioGraphObject, v); attr_args_process(self, argc, argv); } return ObjectPtr(self); }
void WrappedDataClass_new(TTPtr self, long argc, t_atom *argv) { WrappedModularInstancePtr x = (WrappedModularInstancePtr)self; t_symbol* relativeAddress; long attrstart = attr_args_offset(argc, argv); // support normal arguments // check address argument relativeAddress = _sym_nothing; if (attrstart && argv) if (atom_gettype(argv) == A_SYM) relativeAddress = atom_getsym(argv); if (relativeAddress == _sym_nothing) { object_error((t_object*)x, "needs a name as first argument"); return; } // check for reserved address if (relativeAddress == gensym("data/mute") || relativeAddress == gensym("data/bypass") || relativeAddress == gensym("data/freeze") || relativeAddress == gensym("data/preview") || relativeAddress == gensym("audio/mute") || relativeAddress == gensym("audio/bypass") || relativeAddress == gensym("audio/mix") || relativeAddress == gensym("audio/gain") || relativeAddress == gensym("model") || relativeAddress == gensym("preset") ) { object_error((t_object*)x, "%s address is reserved by j.model", relativeAddress->s_name); return; } x->useInternals = false; // Make outlets (before attr_args_process) ///////////////////////////////////////////////////////////////////////////////// // Don't create outlets during dynamic changes x->outlets = (TTHandle)sysmem_newptr(sizeof(TTPtr) * 2); x->outlets[data_out] = outlet_new(x, NULL); // anything outlet to output data // Prepare extra data x->extra = (t_extra*)malloc(sizeof(t_extra)); EXTRA->arrayArgs = new TTValue(); // Store arguments if (argc > 1 && argv) jamoma_ttvalue_from_Atom(*(EXTRA->arrayArgs), _sym_list, argc--, argv++); data_new_address(self, relativeAddress, argc--, argv++); }
void *max_jit_dmxmap_new(t_symbol *s, long argc, t_atom *argv) { t_max_jit_dmxmap *x; void *o,*m; t_jit_matrix_info info; long n; if (x = (t_max_jit_dmxmap *)max_jit_obex_new(class_max_jit_dmxmap,gensym("jit_dmxmap"))) { if (o=jit_object_new(gensym("jit_dmxmap"))) { attr_args_process(x, argc, argv); argc = attr_args_offset(argc, argv); max_jit_obex_jitob_set(x, o); max_jit_obex_dumpout_set(x, outlet_new(x,NULL)); max_jit_mop_setup(x); max_jit_mop_inputs(x); max_jit_mop_outputs(x); if(argc == 1) n = jit_atom_getlong(&argv[0]); else n = 512; m = max_jit_mop_getoutput(x, 1); jit_object_method(m, _jit_sym_getinfo, &info); info.type = _jit_sym_char; info.planecount = 1; info.dimcount = 1; info.dim[0] = n; info.dimstride[0] = 1; info.dimstride[1] = n; jit_object_method(m, _jit_sym_setinfo, &info); //max_jit_obex_jitob_set(x,o); //max_jit_attr_args(x,argc,argv); } else { jit_object_error((t_object *)x,"jit.dmxmap: out of memory"); freeobject((void *)x); x = NULL; goto out; } } out: return (x); }
void *stats_new(t_symbol *s, long argc, t_atom *argv) { t_stats *x; x = (t_stats *)object_alloc(this_class); // create the new instance and return a pointer to it if (x) { long attrstart = attr_args_offset(argc, argv); // Create outlets object_obex_store((void *)x, _sym_dumpout, (object *)outlet_new(x,NULL)); // dumpout x->outlet5 = floatout(x); // 5th outlet: standard deviation x->outlet4 = floatout(x); // 4th outlet: mean x->outlet3 = floatout(x); // 3rd outlet: maximum x->outlet2 = floatout(x); // 2nd outlet: minimum x->outlet = intout(x); // 1st outlet: counter // Setting max window size and actual window size x->maxWindowSize = 0; x->windowSize = 0; if (attrstart && argv) x->maxWindowSize = atom_getlong(argv); if ((attrstart==2) && argv) x->windowSize = atom_getlong(argv+1); if (x->maxWindowSize <= 0) x->maxWindowSize = 500; // changing to default value if (x->windowSize <= 0) x->windowSize = x->maxWindowSize; // changing to default value if (x->windowSize > x->maxWindowSize) x->windowSize = x->maxWindowSize; // making sure we do not read outside array // allocate memory for array x->values = (double *)sysmem_newptr(sizeof(double) * x->maxWindowSize); if (x->values == NULL) { error("j.stats: memory allocation error"); // whoops, out of memory... return 0; } x->attr_windowed = 1; // set default attr_args_process(x, argc, argv); // handle attribute args stats_clear(x); // initilaize instance return (x); // return the pointer to our new instantiation } else return 0; }
void *comb_new(t_symbol *s, short argc, t_atom *argv) { t_comb *x; long attrstart; long arguments[5] = {0, 0, 0, 0, 0}; short i, arguments_len = 0; attrstart = attr_args_offset(argc, argv); // support normal arguments for backward compatibility if(attrstart && argv){ for(i=0; i<attrstart; i++) arguments[i] = atom_getfloat(argv+i); arguments_len = i; } x = (t_comb*)object_alloc(s_comb_class); if(x){ object_obex_store((void *)x, _sym_dumpout, (object *)outlet_new(x, NULL)); // dumpout dsp_setup((t_pxobject *)x, 3); outlet_new((t_object *)x, "signal"); x->attr_buffersize = arguments[0]; if(x->attr_buffersize == 0) x->attr_buffersize = 200.0; x->attr_delay = arguments[1]; x->attr_feedback = arguments[2]; x->attr_autoclip = arguments[3]; x->attr_lowpass = arguments[4]; if(x->attr_lowpass == 0) x->attr_lowpass = 20000.0; tt_audio_base::set_global_sr(sys_getsr()); // set taptools globals with msp's globals... tt_audio_base::set_global_vectorsize(sys_getblksize()); x->mycomb = new tt_comb(x->attr_buffersize); // create taptools comb filter object for(i=0; i<NUM_INPUTS; i++) x->signal_in[i] = new tt_audio_signal; for(i=0; i<NUM_OUTPUTS; i++) x->signal_out[i] = new tt_audio_signal; if(arguments_len >= 2) x->mycomb->set_attr(tt_comb::k_feedback, x->attr_feedback); x->mycomb->set_attr(tt_comb::k_clip, x->attr_autoclip); x->mycomb->set_attr(tt_comb::k_cutoff_frequency, x->attr_lowpass); attr_args_process(x,argc,argv); // handle attribute args } return(x); }
void WrappedCueManagerClass_new(TTPtr self, long argc, t_atom *argv) { WrappedModularInstancePtr x = (WrappedModularInstancePtr)self; t_symbol* name; TTValue v, args; TTObject aTextHandler; long attrstart = attr_args_offset(argc, argv); // support normal arguments // create the cue manager jamoma_cueManager_create((t_object*)x, x->wrappedObject); // read first argument to know if the cue binds a namespace if (attrstart && argv) { if (atom_gettype(argv) == A_SYM) { name = atom_getsym(argv); x->wrappedObject.set(kTTSym_namespace, TTSymbol(name->s_name)); } else object_error((t_object*)x, "argument not expected"); } // Make two outlets x->outlets = (TTHandle)sysmem_newptr(sizeof(TTPtr) * 1); x->outlets[line_out] = outlet_new(x, NULL); // anything outlet to output data // Prepare Internals hash to store TextHandler object x->internals = new TTHash(); // create internal TTTextHandler aTextHandler = TTObject(kTTSym_TextHandler); x->internals->append(kTTSym_TextHandler, aTextHandler); // Prepare extra data x->extra = (t_extra*)malloc(sizeof(t_extra)); EXTRA->toEdit = new TTObject(); *EXTRA->toEdit = x->wrappedObject; EXTRA->cueName = kTTSymEmpty; EXTRA->text = NULL; EXTRA->textEditor = NULL; // handle attribute args attr_args_process(x, argc, argv); }
void WrappedNodeInfoClass_new(TTPtr self, long argc, t_atom* argv) { WrappedModularInstancePtr x = (WrappedModularInstancePtr)self; t_symbol *relativeAddress; long attrstart = attr_args_offset(argc, argv); // support normal arguments // check address argument relativeAddress = _sym_nothing; if (attrstart && argv) if (atom_gettype(argv) == A_SYM) relativeAddress = atom_getsym(argv); if (relativeAddress == _sym_nothing) { pd_error((t_object*)x, "needs a name as first argument"); return; } // check for reserved address if (relativeAddress == gensym("data/mute") || relativeAddress == gensym("data/bypass") || relativeAddress == gensym("data/freeze") || relativeAddress == gensym("data/preview") || relativeAddress == gensym("audio/mute") || relativeAddress == gensym("audio/bypass") || relativeAddress == gensym("audio/mix") || relativeAddress == gensym("audio/gain") || relativeAddress == gensym("model") || relativeAddress == gensym("preset") ) { pd_error((t_object*)x, "%s address is reserved by j.model", relativeAddress->s_name); return; } jamoma_node_info_create((t_object*)x, x->wrappedObject); if (argc && argv) attr_args_process(x, argc, argv); // The following must be deferred because we have to interrogate our box, // and our box is not yet valid until we have finished instantiating the object. // Trying to use a loadbang method instead is also not fully successful (as of Max 5.0.6) node_subscribe(x,relativeAddress, argc, argv); // defer_low((t_object*)x, (method)node_subscribe, relativeAddress, argc, argv); }
void *decibels_new(t_symbol *msg, short argc, t_atom *argv) { t_decibels *x; long attrstart; t_atom_long argument = 0; attrstart = attr_args_offset(argc, argv); if (attrstart && argv) atom_arg_getlong(&argument, 0, attrstart, argv); // support a normal int argument for bwc if (x = (t_decibels *)object_alloc(decibels_class)) { object_obex_store((void *)x, _sym_dumpout, (object *)outlet_new(x,NULL)); // dumpout dsp_setup((t_pxobject *)x,1); x->decibels_out = floatout(x); // Create a floating-point Outlet outlet_new((t_object *)x, "signal"); // Handle Arguments... if (msg == gensym("tap.atodb~")){ x->moden = 0; object_post((t_object *)x, " tap.decibels~ initialized in mode 0"); } else if (msg == gensym("tap.dbtoa~")){ x->moden = 1; object_post((t_object *)x, " tap.decibels~ initialized in mode 1"); } else x->moden = argument; switch(x->moden){ case 0: x->attr_mode = ps_amp2db; break; case 1: x->attr_mode = ps_db2amp; break; case 2: x->attr_mode = ps_mm2db; break; case 3: x->attr_mode = ps_db2mm; break; case 4: x->attr_mode = ps_mm2amp; break; case 5: x->attr_mode = ps_amp2mm; break; case 6: x->attr_mode = ps_db2midi; break; case 7: x->attr_mode = ps_midi2db; break; } attr_args_process(x,argc,argv); //handle attribute args } return (x); }
// Create void *send_new(t_symbol *s, long argc, t_atom *argv) { long attrstart = attr_args_offset(argc, argv); // support normal arguments t_send *x = (t_send *)object_alloc(s_send_class); if(x){ object_obex_store((void *)x, _sym_dumpout, (object *)outlet_new(x, NULL)); if(attrstart > 0) x->attr_name = atom_getsym(argv); else x->attr_name = gensym("jcom.send no arg specified"); attr_args_process(x, argc, argv); // handle attribute args if(!g_receivemaster_object) g_receivemaster_object = (t_object *)object_new(CLASS_NOBOX, gensym("jcom.receivemaster")); } return x; }
// Create void* gain_new(t_symbol* s, long argc, t_atom* argv) { long attrstart = attr_args_offset(argc, argv); // support normal arguments short i; t_gain* x = (t_gain*)object_alloc(s_gain_class); if(x){ object_obex_store((void*)x, _sym_dumpout, (object*)outlet_new(x, NULL)); // dumpout x->numChannels = 1; if(attrstart && argv){ int argument = atom_getlong(argv); x->numChannels = TTClip(argument, 1, MAX_NUM_CHANNELS); } dsp_setup((t_pxobject*)x, x->numChannels * 2); // Create Object and Inlets x->obj.z_misc = Z_NO_INPLACE; // ESSENTIAL! for(i=0; i < x->numChannels; i++) outlet_new((t_pxobject*)x, "signal"); // Create a signal Outlet //x->xfade = new TTCrossfade(x->numChannels); // Constructors //x->gain = new TTGain(x->numChannels); TTObjectBaseInstantiate(TT("crossfade"), &x->xfade, x->numChannels); TTObjectBaseInstantiate(TT("gain"), &x->gain, x->numChannels); TTObjectBaseInstantiate(kTTSym_audiosignal, &x->signalTemp, x->numChannels); TTObjectBaseInstantiate(kTTSym_audiosignal, &x->signalOut, x->numChannels); TTObjectBaseInstantiate(kTTSym_audiosignal, &x->signalIn, x->numChannels*2); //x->signalTemp = new TTAudioSignal(x->numChannels); //x->signalOut = new TTAudioSignal(x->numChannels); //x->signalIn = new TTAudioSignal(x->numChannels*2); x->xfade->setAttributeValue(TT("position"), 1.0); // defaults x->gain->setAttributeValue(TT("linearGain"), 0.0); x->attrBypass = 0; x->attrGain = 0; attr_args_process(x, argc, argv); // handle attribute args } return (x); // Return the pointer }
void *sieve_new(t_symbol *msg, short argc, t_atom *argv) { t_sieve *x; long attrstart; long argument = 0; attrstart = attr_args_offset(argc, argv); if (attrstart && argv) argument = atom_getlong(argv); // support a normal int argument for bwc x = (t_sieve *)object_alloc(s_sieve_class);;// create the new instance and return a pointer to it if(x){ object_obex_store((void *)x, _sym_dumpout, (object *)outlet_new(x,NULL)); // dumpout x->value = argument; x->outlet = intout(x); x->right_inlet = proxy_new(x, 1, 0L); attr_args_process(x,argc,argv); //handle attribute args } return(x); }
void* testequals_new(t_symbol *s, long argc, t_atom *argv) { t_testequals *x = (t_testequals*)object_alloc(s_testequals_class); long attrstart = attr_args_offset((short)argc, argv); if (attrstart) x->x_operand = atom_getfloat(argv); x->x_outlet = outlet_new(x, NULL); x->x_inlet = proxy_new(x, 1, NULL); x->x_tolerance = 2; #ifdef C74_X64 x->x_single_precision = false; #else x->x_single_precision = true; #endif attr_args_process(x, (short)argc, argv); autocolorbox((t_object*)x); return x; }
PackPtr PackNew(SymbolPtr msg, AtomCount argc, AtomPtr argv) { PackPtr self; TTValue sr(sys_getsr()); long attrstart = attr_args_offset(argc, argv); TTValue v; TTErr err; self =PackPtr(object_alloc(sInClass)); if (self) { self->maxNumChannels = 2; if (attrstart && argv) self->maxNumChannels = atom_getlong(argv); ttEnvironment->setAttributeValue(kTTSym_sampleRate, sr); v.setSize(3); v.set(0, TT("audio.generator")); v.set(1, 0); // no audio graph inlets (only msp inlets) v.set(2, 1); // one audio graph outlet err = TTObjectBaseInstantiate(TT("audio.object"), (TTObjectBasePtr*)&self->audioGraphObject, v); self->audioGraphObject->addAudioFlag(kTTAudioGraphGenerator); if (!self->audioGraphObject->getUnitGenerator()) { object_error(SELF, "cannot load audio.generator"); return NULL; } attr_args_process(self, argc, argv); object_obex_store((void*)self, _sym_dumpout, (object*)outlet_new(self,NULL)); self->audioGraphObjectOutlet = outlet_new((t_pxobject*)self, "audio.connect"); dsp_setup((t_pxobject*)self, self->maxNumChannels); self->obj.z_misc = Z_NO_INPLACE | Z_PUT_FIRST; } return self; }
void *return_new(t_symbol *s, long argc, t_atom *argv) { long attrstart = attr_args_offset(argc, argv); t_return* x = (t_return *)object_alloc(return_class); t_symbol* name = _sym_nothing; ObjectPtr patcher = NULL; if (attrstart && argv) atom_arg_getsym(&name, 0, attrstart, argv); else name = symbol_unique(); // for instances buried inside of another object: // we pass a second argument which is a pointer to the patcher if (attrstart>1 && argv) patcher = ObjectPtr(atom_getobj(argv+1)); if (x) { x->outlets[k_outlet_dumpout] = outlet_new(x, 0L); object_obex_store((void *)x, _sym_dumpout, (t_object *)x->outlets[k_outlet_dumpout]); x->outlets[k_outlet_thru] = outlet_new(x, 0L); jcom_core_subscriber_new_extended(&x->common, name, jps_subscribe_return); atom_setsym(&x->output[0], name); x->output_len = 1; x->attrEnable = true; x->attrDataspace = jps_none; x->attrUnitNative = jps_none; if (patcher) x->common.container = patcher; attr_args_process(x, argc, argv); jcom_core_subscriber_subscribe((t_jcom_core_subscriber_common*)x); return_makesend(x); } return (x); }