void match_set(t_match *x, t_symbol *s, short ac, t_atom *av)
{
t_atom *temp;
char savelock;
if (!ac)
return;
if (ac != x->m_size)
temp = (t_atom *)sysmem_newptr((long)ac * sizeof(t_atom));
else
temp = x->m_want;
match_setwant(temp,ac,av);
savelock = lockout_set(1);
critical_enter(x->m_critical);
if (ac != x->m_size) {
match_freebytes(x);
x->m_want = temp;
x->m_seen = (t_atom *)sysmem_newptr((long)ac * sizeof(t_atom));
}
x->m_size = ac;
match_clear(x);
lockout_set(savelock);
critical_exit(x->m_critical);
}
// DSP Method
void fade_dsp(t_fade *x, t_signal **sp, short *count)
{
short i, j, k, l=0;
void **audioVectors = NULL;
TTUInt8 numChannels = 0;
TTUInt16 vs = 0;
if(count[x->numChannels * 2]) // SIGNAL RATE CROSSFADE CONNECTED
audioVectors = (void**)sysmem_newptr(sizeof(void*) * ((x->numChannels * 3) + 2));
else // CONTROL RATE CROSSFADE
audioVectors = (void**)sysmem_newptr(sizeof(void*) * ((x->numChannels * 3) + 1));
audioVectors[l] = x;
l++;
// audioVectors[] passed to balance_perform() as {x, audioInL[0], audioInR[0], audioOut[0], audioInL[1], audioInR[1], audioOut[1],...}
for(i=0; i < x->numChannels; i++){
j = x->numChannels + i;
k = x->numChannels*2 + i + 1; // + 1 to account for the position input
if(count[i] && count[j] && count[k]){
numChannels++;
if(sp[i]->s_n > vs)
vs = sp[i]->s_n;
audioVectors[l] = sp[i]->s_vec;
l++;
audioVectors[l] = sp[j]->s_vec;
l++;
audioVectors[l] = sp[k]->s_vec;
l++;
}
}
if(count[x->numChannels * 2]){ // SIGNAL RATE CROSSFADE CONNECTED
audioVectors[l] = sp[x->numChannels*2]->s_vec;
l++;
}
x->audioIn1->setNumChannels(numChannels);
x->audioIn2->setNumChannels(numChannels);
x->audioOut->setNumChannels(numChannels);
x->audioIn1->setVectorSizeWithInt(vs);
x->audioIn2->setVectorSizeWithInt(vs);
x->audioOut->setVectorSizeWithInt(vs);
//audioIn will be set in the perform method
x->audioOut->alloc();
x->xfade->setAttributeValue(kTTSym_sampleRate, sp[0]->s_sr);
if(count[x->numChannels * 2]) // SIGNAL RATE CROSSFADE CONNECTED
dsp_addv(fade_perform2, l, audioVectors);
else
dsp_addv(fade_perform1, l, audioVectors);
sysmem_freeptr(audioVectors);
}
t_jit_err jit_gl_terrain_maxdim(t_jit_gl_terrain *x, void *attr, long argc, t_atom *argv)
{
long temp[2], i,j;
float *vertnorms, *posit, *facenorms,*texcoords;
if (argc&&argv) {
temp[0] = jit_atom_getlong(argv+0);
temp[1] = jit_atom_getlong(argv+1);
}
x->maxdim[0] = CLIP(temp[0], 256, 65535);
x->maxdim[1] = CLIP(temp[1], 256, 65535);
// replace with resize pointer!! important! and defer mem calling
// alloc memory here
if (x->posit) {
sysmem_freeptr(x->posit);
post("just free 'd posit");
}
x->posit= sysmem_newptr(x->maxdim[0]*x->maxdim[1]*sizeof(float));
if(x->posit) {
post("alloced posit %ld * %ld * %ld \(sizeof\(double\)\) = %ld bytes",x->maxdim[0], x->maxdim[1],sizeof(float),x->maxdim[0]*x->maxdim[1]*sizeof(float));
} else {
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);
}
FLEXT_TEMPIMPL(void *FLEXT_CLASSDEF(flext_root))::NewAligned(size_t bytes,int bitalign)
{
const size_t ovh = sizeof(size_t)+sizeof(char *);
const size_t alignovh = bitalign/8-1;
bytes += ovh+alignovh;
char *blk;
if(UNLIKELY(bytes >= LARGEALLOC)) {
#if FLEXT_SYS == FLEXT_SYS_MAX && defined(_SYSMEM_H_)
blk = (char *)sysmem_newptr(bytes);
#else
// use C library function for large memory blocks
blk = (char *)malloc(bytes);
#endif
}
else {
//! We need system locking here for secondary threads!
SYSLOCK();
#if defined(FLEXT_USE_CMEM)
blk = (char *)malloc(bytes);
#else
blk = (char *)getbytes(bytes);
#endif
SYSUNLOCK();
}
FLEXT_ASSERT(blk);
char *ablk = reinterpret_cast<char *>((reinterpret_cast<size_t>(blk)+ovh+alignovh) & ~alignovh);
*(char **)(ablk-sizeof(size_t)-sizeof(char *)) = blk;
*(size_t *)(ablk-sizeof(size_t)) = bytes;
return ablk;
}
void *dict_recurse_new(t_symbol *sym, long argc, t_atom *argv)
{
t_dict_recurse *x = NULL;
x = (t_dict_recurse *)object_alloc(dict_recurse_class);
if (x == NULL) {
MY_ERR("Object allocation failed.");
return NULL; }
x->outl_bang = bangout(x); // Outler 1: Bang on completion
x->outl_mess = outlet_new((t_object*)x, NULL); // Outlet 0: General messages
x->path_len_max = MAX_LEN_PATH;
x->path = NULL;
x->path = (char *)sysmem_newptr(sizeof(char) * x->path_len_max);
if (!x->path) { MY_ERR("new: Allocation error for \"path\"."); }
x->search_key_expr = regexpr_new();
x->search_val_expr = regexpr_new();
if (!x->search_key_expr || !x->search_val_expr) {
MY_ERR("new: Allocation error for the search expressions."); }
_dict_recurse_reset(x);
re_set_object(x);
x->re2 = re_new(254);
if (!x->re2) { return NULL; }
return(x);
}
void inquisitor_attributes(t_inquisitor* x)
{
t_symbol** names = NULL;
long count = 0;
t_atom* av = NULL;
if(!x->subject){
t_object* b = jpatcher_get_firstobject(x->patcher);
while(b){
if(x->name == jbox_get_varname(b)){
x->subject = jbox_get_object(b);
break;
}
b = jbox_get_nextobject(b);
}
}
if(x->subject){
object_attr_getnames(x->subject, &count, (t_symbol***)&names);
if(count && names){
av = (t_atom*)sysmem_newptr(sizeof(t_atom) * count);
for(long i=0; i<count; i++)
atom_setsym(av+i, names[i]);
outlet_anything(x->outlet_names, atom_getsym(av), count-1, av+1);
sysmem_freeptr(av);
sysmem_freeptr(names);
}
}
}
t_an_item *an_item_new(t_symbol *s, long items)
{
t_an_item *x = (t_an_item *)sysmem_newptr(sizeof(t_an_item));
x->name = s;
x->val = items;
return (x);
}
// DSP Method
void PackDsp(PackPtr self, t_signal** sp, short* count)
{
TTUInt16 i, k=0;
void **audioVectors = NULL;
TTUInt16 highestIndexForConnectedSignal = 0;
self->vectorSize = sp[0]->s_n;
// Setup the perform method
audioVectors = (void**)sysmem_newptr(sizeof(void*) * (self->maxNumChannels + 1));
audioVectors[k] = self;
k++;
self->numChannels = 0;
for (i=0; i < self->maxNumChannels; i++) {
self->numChannels++;
audioVectors[k] = sp[i]->s_vec;
k++;
if (count[i])
highestIndexForConnectedSignal = i;
}
self->audioGraphObject->setOutputNumChannels(0, highestIndexForConnectedSignal+1);
self->audioGraphObject->getUnitGenerator()->setAttributeValue(kTTSym_vectorSize, (uint)self->vectorSize);
self->audioGraphObject->getUnitGenerator()->setAttributeValue(kTTSym_maxNumChannels, (uint)self->maxNumChannels);
self->audioGraphObject->getUnitGenerator()->setAttributeValue(kTTSym_sampleRate, (uint)sp[0]->s_sr);
dsp_addv(PackPerform, k, audioVectors);
sysmem_freeptr(audioVectors);
}
// DSP Method
void in_dsp(TTPtr self, t_signal **sp, short *count)
{
WrappedModularInstancePtr x = (WrappedModularInstancePtr)self;
TTInputPtr anInput = (TTInputPtr)x->wrappedObject;
void** audioVectors = NULL;
TTUInt16 vectorSize = 0;
if (anInput) {
audioVectors = (void**)sysmem_newptr(sizeof(void*) * 3);
audioVectors[0] = x;
if (count[0] || count[1]) {
if (sp[0]->s_n > vectorSize)
vectorSize = sp[0]->s_n;
audioVectors[1] = sp[0]->s_vec;
audioVectors[2] = sp[1]->s_vec;
}
// set signal numChannels and vectorSize
anInput->mSignalIn->setAttributeValue(kTTSym_numChannels, 1);
anInput->mSignalOut->setAttributeValue(kTTSym_numChannels, 1);
anInput->mSignalIn->setAttributeValue(kTTSym_vectorSize, vectorSize);
anInput->mSignalOut->setAttributeValue(kTTSym_vectorSize, vectorSize);
// anInput->mSignalIn will be set in the perform method
anInput->mSignalOut->sendMessage(kTTSym_alloc);
dsp_addv(in_perform, 3, audioVectors);
sysmem_freeptr(audioVectors);
}
}
FLEXT_TEMPIMPL(void *FLEXT_CLASSDEF(flext_root))::operator new(size_t bytes)
{
bytes += sizeof(size_t);
#ifdef FLEXT_DEBUGMEM
bytes += sizeof(memtest)*2;
#endif
char *blk;
if(UNLIKELY(bytes >= LARGEALLOC)) {
#if FLEXT_SYS == FLEXT_SYS_MAX && defined(_SYSMEM_H_)
blk = (char *)sysmem_newptr(bytes);
#else
// use C library function for large memory blocks
blk = (char *)malloc(bytes);
#endif
}
else {
//! We need system locking here for secondary threads!
SYSLOCK();
blk = (char *)getbytes(bytes);
SYSUNLOCK();
}
FLEXT_ASSERT(blk);
*(size_t *)blk = bytes;
#ifdef FLEXT_DEBUGMEM
*(size_t *)(blk+sizeof(size_t)) = memtest;
*(size_t *)(blk+bytes-sizeof(memtest)) = memtest;
return blk+sizeof(size_t)+sizeof(memtest);
#else
return blk+sizeof(size_t);
#endif
}
void *bkout_new(t_symbol *msg, short argc, t_atom *argv){
t_bkout *x;
if(x = (t_bkout *)object_alloc(bkout_class)){
dsp_setup((t_pxobject *)x, 0);
x->name = NULL;
x->function = 0;
attr_args_process(x, argc, argv);
if(x->name == NULL){
error("te_breakout~: you must supply a name");
return NULL;
}
//x->outlets = (t_float **)sysmem_newptr(x->numoutlets * sizeof(t_float *));
x->outlets = (double **)sysmem_newptr(x->numoutlets * sizeof(double *));
int i;
for(i = 0; i < x->numoutlets; i++){
outlet_new(x, "signal");
}
x->ob.z_misc = Z_PUT_LAST;
return x;
}
return NULL;
}
MaxErr OpGetOperand(OpPtr self, ObjectPtr attr, AtomCount* argc, AtomPtr* argv)
{
TTValue v;
self->audioGraphObject->getUnitGenerator()->getAttributeValue(TT("operand"), v);
*argc = v.getSize();
if (!(*argv)) // otherwise use memory passed in
*argv = (t_atom *)sysmem_newptr(sizeof(t_atom) * v.getSize());
for (int i=0; i<v.getSize(); i++) {
if(v.getType(i) == kTypeFloat32 || v.getType(i) == kTypeFloat64){
TTFloat64 value;
v.get(i, value);
atom_setfloat(*argv+i, value);
}
else if(v.getType(i) == kTypeSymbol){
TTSymbol value;
v.get(i, value);
atom_setsym(*argv+i, gensym((char*)value.c_str()));
}
else{ // assume int
TTInt32 value;
v.get(i, value);
atom_setlong(*argv+i, value);
}
}
return MAX_ERR_NONE;
}
// 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 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);
}
t_max_err jcom_core_attr_getclipmode(t_jcom_core_subscriber_extended *x, void *attr, long *argc, t_atom **argv)
{
*argc = 1;
if (!(*argv)) // otherwise use memory passed in
*argv = (t_atom *)sysmem_newptr(sizeof(t_atom));
atom_setsym(*argv, x->attr_clipmode);
return MAX_ERR_NONE;
}
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);
}
t_max_err return_attr_gettype(t_return *x, void *attr, long *argc, t_atom **argv)
{
*argc = 1;
if (!(*argv)) // otherwise use memory passed in
*argv = (t_atom *)sysmem_newptr(sizeof(t_atom));
atom_setsym(*argv, x->common.attr_type);
return MAX_ERR_NONE;
}
// DSP Method
void out_dsp(t_out *x, t_signal **sp, short *count)
{
short i, j, k=0;
void** audioVectors = NULL;
TTUInt8 numChannels = 0;
TTUInt16 vs = sp[0]->s_n;
int sr = sp[0]->s_sr;
x->ramp_gain->setAttributeValue(TT("sr"), sr); // convert midi to db for tap_gain
x->ramp_xfade->setAttributeValue(TT("sr"), sr); // convert midi to db for tap_gain
audioVectors = (void**)sysmem_newptr(sizeof(void*) * ((x->numOutputs * 2) + 1));
audioVectors[k] = x;
k++;
for(i=0; i < x->numOutputs; i++){
j = x->numOutputs + i;
if(count[i] || count[j]){
numChannels++;
if(sp[i]->s_n > vs)
vs = sp[i]->s_n;
audioVectors[k] = sp[i]->s_vec;
k++;
audioVectors[k] = sp[j]->s_vec;
k++;
}
}
x->numChannels = numChannels;
x->audioIn->setAttributeValue(TT("numChannels"), numChannels);
x->audioOut->setAttributeValue(TT("numChannels"), numChannels);
x->audioTemp->setAttributeValue(TT("numChannels"), numChannels);
x->zeroSignal->setAttributeValue(TT("numChannels"), numChannels);
x->vectorSize = vs;
x->audioIn->setAttributeValue(TT("vectorSize"), vs);
x->audioOut->setAttributeValue(TT("vectorSize"), vs);
x->audioTemp->setAttributeValue(TT("vectorSize"), vs);
x->zeroSignal->setAttributeValue(TT("vectorSize"), vs);
//audioIn will be set in the perform method
x->audioOut->sendMessage(TT("alloc"));
x->audioTemp->sendMessage(TT("alloc"));
x->zeroSignal->sendMessage(TT("alloc"));
x->zeroSignal->sendMessage(TT("clear"));
dsp_addv(out_perform, k, audioVectors);
sysmem_freeptr(audioVectors);
// start the meters
if(x->num_meter_objects){
for(i=0; i<MAX_NUM_CHANNELS; i++)
x->peakamp[i] = 0;
clock_delay(x->clock, kPollIntervalDefault); // start the clock
}
}
void munger_alloc(t_munger *x)
{
//x->recordBuf = t_getbytes(BUFLENGTH * sizeof(float));
//x->recordBuf = t_getbytes(x->buflen * sizeof(float));
x->recordBuf = (float *)sysmem_newptr(x->buflen * sizeof(float));
if (!x->recordBuf) {
error("munger: out of memory");
return;
}
}
void bed_fadeout(t_bed *x, double fadetime)
{
if (!bed_attach_buffer(x)) {
return;
}
t_buffer *b;
b = x->buffer;
ATOMIC_INCREMENT(&b->b_inuse);
if (!b->b_valid) {
ATOMIC_DECREMENT(&b->b_inuse);
post("bed • Not a valid buffer!");
return;
}
long fadeframes = fadetime * 0.001 * b->b_sr;
if (fadetime <= 0 || fadeframes > b->b_frames) {
post("bed • %.0fms is not a valid fade-out time", fadetime);
ATOMIC_DECREMENT(&b->b_inuse);
return;
}
long chunksize = fadeframes * b->b_nchans * sizeof(float);
if (x->undo_samples == NULL) {
x->undo_samples = (float *)sysmem_newptr(chunksize);
} else {
x->undo_samples = (float *)sysmem_resizeptr(x->undo_samples, chunksize);
}
if (x->undo_samples == NULL) {
error("bed • Cannot allocate memory for undo");
x->can_undo = 0;
ATOMIC_DECREMENT(&b->b_inuse);
return;
} else {
x->can_undo = 1;
x->undo_start = b->b_frames - fadeframes;
x->undo_frames = fadeframes;
x->undo_resize = 0;
x->undo_cut = 0;
sysmem_copyptr(b->b_samples + x->undo_start, x->undo_samples, chunksize);
}
for (int ii = (int)x->undo_start; ii < x->undo_start + fadeframes; ii++) {
for (int jj = 0; jj < b->b_nchans; jj++) {
b->b_samples[(ii * b->b_nchans) + jj] *=
1 - (float)(ii - x->undo_start) / (float)fadeframes;
}
}
object_method(&b->b_obj, gensym("dirty"));
ATOMIC_DECREMENT(&b->b_inuse);
}
void *match_new(t_symbol *s, short ac, t_atom *av)
{
t_match *x;
x = object_alloc(match_class);
x->m_out = outlet_new((t_object *)x,0);
critical_new(&x->m_critical);
if (ac) {
x->m_want = (t_atom *)sysmem_newptr((long)ac * sizeof(t_atom));
match_setwant(x->m_want,ac,av);
x->m_seen = (t_atom *)sysmem_newptr((long)ac * sizeof(t_atom));
x->m_size = ac;
match_clear(x);
} else {
x->m_seen = 0;
x->m_want = 0;
x->m_size = 0;
}
return x;
}
void omax_class_addToSchemaList(t_class *c, const char *address)
{
t_symbol *classname = class_nameget(c);
if(!classname){
return;
}
t_hashtab *ht = omax_class_getHashtab(classname->s_name);
if(!ht){
return;
}
t_schemalist *sl = NULL;
hashtab_lookup(ht, gensym("cnmat_internal_osc_schema_list"), (t_object **)(&sl));
if(!sl){
sl = (t_schemalist *)sysmem_newptr(sizeof(t_schemalist));
sl->address_buf_len = 64;
sl->addresses = (t_charbuffer *)sysmem_newptr(sl->address_buf_len * sizeof(t_charbuffer));
sl->address_buf_pos = 0;
sl->nbytes = 0;
hashtab_store(ht, gensym("cnmat_internal_osc_schema_list"), (t_object *)sl);
}
int len = strlen(address);
len++;
while(len % 4){
len++;
}
if(sl->address_buf_pos >= sl->address_buf_len){
sl->addresses = (t_charbuffer *)sysmem_resizeptr(sl->addresses, sizeof(t_charbuffer) * (sl->address_buf_len + 16));
if(!sl->addresses){
return;
}
sl->address_buf_len += 16;
}
t_charbuffer *cb = sl->addresses + sl->address_buf_pos;
cb->buf = (char *)sysmem_newptr(len);
memset(cb->buf, '\0', len);
strcpy(cb->buf, address);
cb->bufpos = len;
cb->buflen = len;
sl->address_buf_pos++;
sl->nbytes += len;
}
Chordid(t_symbol * sym, long ac, t_atom * av)
: c(frameSize, sampleRate), chordspotter()
{
c.setChromaCalculationInterval(512);
frame.resize(frameSize);
m_outlets = (void **)sysmem_newptr(sizeof(void *) * numoutlets);
for (unsigned int i = 0; i < numoutlets; i++){
m_outlets[numoutlets - i - 1] = outlet_new(this, NULL); // generic outlet
}
setupIO(1, 1);
// post("object created");
}
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 iter_resize(t_iter *x, long size)
{
if (size!=x->i_ac) {
if (x->i_av)
sysmem_freeptr(x->i_av);
if (size)
x->i_av = (t_atom *)sysmem_newptr(size*sizeof(t_atom));
else
x->i_av = NULL;
x->i_ac = size;
}
}
// thread protection for resizing is handled by this function's caller
void minimum_resize(t_minimum *x, long size)
{
if (size!=x->m_count) {
if (x->m_args)
sysmem_freeptr(x->m_args);
if (size)
x->m_args = (t_atom *)sysmem_newptr(size*sizeof(t_atom));
else
x->m_args = NULL;
x->m_count = size;
}
}
void bed_reverse(t_bed *x)
{
if (!bed_attach_buffer(x)) {
return;
}
t_buffer *b;
b = x->buffer;
ATOMIC_INCREMENT(&b->b_inuse);
if (!b->b_valid) {
ATOMIC_DECREMENT(&b->b_inuse);
post("bed • Not a valid buffer!");
return;
}
long chunksize = b->b_frames * b->b_nchans * sizeof(float);
if (x->undo_samples == NULL) {
x->undo_samples = (float *)sysmem_newptr(chunksize);
} else {
x->undo_samples = (float *)sysmem_resizeptr(x->undo_samples, chunksize);
}
if (x->undo_samples == NULL) {
error("bed • Cannot allocate memory for undo");
x->can_undo = 0;
ATOMIC_DECREMENT(&b->b_inuse);
return;
} else {
x->can_undo = 1;
x->undo_start = 0;
x->undo_frames = b->b_frames;
x->undo_resize = 0;
x->undo_cut = 0;
sysmem_copyptr(b->b_samples, x->undo_samples, chunksize);
}
float temp;
for (int ii = 0; ii < ceil(b->b_frames / 2); ii++) {
for (int jj = 0; jj < b->b_nchans; jj++) {
temp = b->b_samples[(ii * b->b_nchans) + jj];
b->b_samples[(ii * b->b_nchans) + jj] =
b->b_samples[(b->b_frames - 1 - ii * b->b_nchans) + jj];
b->b_samples[(b->b_frames - 1 - ii * b->b_nchans) + jj] = temp;
}
}
object_method(&b->b_obj, gensym("dirty"));
ATOMIC_DECREMENT(&b->b_inuse);
}
t_max_err jcom_core_attr_getrange(t_jcom_core_subscriber_extended *x, void *attr, long *argc, t_atom **argv)
{
*argc = 2;
//sysmem_ptrsize(*argv)
// FIXME: This checks if we have memory passed in, good, but how do we know if it is enough memory for 2 atoms? [TAP]
if (!(*argv)) // otherwise use memory passed in
*argv = (t_atom *)sysmem_newptr(sizeof(t_atom) * 2);
atom_setfloat(*argv, x->attr_range[0]);
atom_setfloat(*argv+1, x->attr_range[1]);
return MAX_ERR_NONE;
}
void ui_return_preset_names(TTPtr self, t_symbol *msg, long argc, t_atom* argv)
{
t_ui* obj = (t_ui*)self;
obj->preset_num = argc;
if (obj->preset_names)
sysmem_freeptr(obj->preset_names);
obj->preset_names = (t_atom*)sysmem_newptr(sizeof(t_atom) * argc);
for (int i=0; i<argc; i++) {
atom_setsym(&obj->preset_names[i], atom_getsym(&argv[i]));
}
}
