自学教程：C++ sysmem_newptr函数代码示例

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

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

// Createvoid *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 Methodvoid 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 
C++ sysmessage函数代码示例
C++ sysmem_freeptr函数代码示例