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