sigrid/leaf

Binary file not shown.

LEAF/Inc/leaf-instruments.h+1−1

@@ -44,7 +44,7 @@ extern "C" { · 43 unmodified lines
44	tHighpass highpass;	44	tHighpass highpass;
45	float oscMix;	45	float oscMix;
46	float filterCutoff;	46	float filterCutoff;
47	oBool useStick;	47	uint8_t useStick;
48		48
49	} _t808Cowbell;	49	} _t808Cowbell;
50		50

LEAF/Inc/leaf-mempool.h+10−10

@@ -63,7 +63,7 @@ extern "C" { · 62 unmodified lines
63		63
64	// node of free list	64	// node of free list
65	typedef struct mpool_node_t {	65	typedef struct mpool_node_t {
66	void *pool; // memory pool field	66	char *pool; // memory pool field
67	struct mpool_node_t *next; // next node pointer	67	struct mpool_node_t *next; // next node pointer
68	struct mpool_node_t *prev; // prev node pointer	68	struct mpool_node_t *prev; // prev node pointer
69	size_t size;	69	size_t size;
@@ -71,7 +71,7 @@ extern "C" { · 1 unmodified line
71		71
72	typedef struct _tMempool	72	typedef struct _tMempool
73	{	73	{
74	void* mpool; // start of the mpool	74	char* mpool; // start of the mpool
75	size_t usize; // used size of the pool	75	size_t usize; // used size of the pool
76	size_t msize; // max size of the pool	76	size_t msize; // max size of the pool
77	mpool_node_t* head; // first node of memory pool free list	77	mpool_node_t* head; // first node of memory pool free list
@@ -117,7 +117,7 @@ extern "C" { · 39 unmodified lines
117	//==============================================================================	117	//==============================================================================
118		118
119	// typedef struct mpool_t {	119	// typedef struct mpool_t {
120	// void* mpool; // start of the mpool	120	// char* mpool; // start of the mpool
121	// size_t usize; // used size of the pool	121	// size_t usize; // used size of the pool
122	// size_t msize; // max size of the pool	122	// size_t msize; // max size of the pool
123	// mpool_node_t* head; // first node of memory pool free list	123	// mpool_node_t* head; // first node of memory pool free list
@@ -125,25 +125,25 @@ extern "C" { · 1 unmodified line
125		125
126	void mpool_create (char* memory, size_t size, _tMempool* pool);	126	void mpool_create (char* memory, size_t size, _tMempool* pool);
127		127
128	void* mpool_alloc(size_t size, _tMempool* pool);	128	char* mpool_alloc(size_t size, _tMempool* pool);
129	void* mpool_calloc(size_t asize, _tMempool* pool);	129	char* mpool_calloc(size_t asize, _tMempool* pool);
130		130
131	void mpool_free(void* ptr, _tMempool* pool);	131	void mpool_free(char* ptr, _tMempool* pool);
132		132
133	size_t mpool_get_size(_tMempool* pool);	133	size_t mpool_get_size(_tMempool* pool);
134	size_t mpool_get_used(_tMempool* pool);	134	size_t mpool_get_used(_tMempool* pool);
135		135
136	void leaf_pool_init(char* memory, size_t size);	136	void leaf_pool_init(char* memory, size_t size);
137		137
138	void* leaf_alloc(size_t size);	138	char* leaf_alloc(size_t size);
139	void* leaf_calloc(size_t size);	139	char* leaf_calloc(size_t size);
140		140
141	void leaf_free(void* ptr);	141	void leaf_free(char* ptr);
142		142
143	size_t leaf_pool_get_size(void);	143	size_t leaf_pool_get_size(void);
144	size_t leaf_pool_get_used(void);	144	size_t leaf_pool_get_used(void);
145		145
146	void* leaf_pool_get_pool(void);	146	char* leaf_pool_get_pool(void);
147		147
148	void leaf_mempool_overrun(void);	148	void leaf_mempool_overrun(void);
149		149

LEAF/Inc/leaf-oscillators.h+3−3

@@ -98,7 +98,7 @@ extern "C" { · 97 unmodified lines
98	// Underlying phasor	98	// Underlying phasor
99	float phase;	99	float phase;
100	float inc,freq;	100	float inc,freq;
101	TableName oct;	101	int oct;
102	float w;	102	float w;
103	} _tTriangle;	103	} _tTriangle;
104		104
@@ -166,7 +166,7 @@ extern "C" { · 61 unmodified lines
166	// Underlying phasor	166	// Underlying phasor
167	float phase;	167	float phase;
168	float inc,freq;	168	float inc,freq;
169	TableName oct;	169	int oct;
170	float w;	170	float w;
171	} _tSquare;	171	} _tSquare;
172		172
@@ -234,7 +234,7 @@ extern "C" { · 61 unmodified lines
234	// Underlying phasor	234	// Underlying phasor
235	float phase;	235	float phase;
236	float inc,freq;	236	float inc,freq;
237	TableName oct;	237	int oct;
238	float w;	238	float w;
239	} _tSawtooth;	239	} _tSawtooth;
240		240

LEAF/Inc/leaf-tables.h+5−1

@@ -19,7 +19,11 @@ extern "C" { · 18 unmodified lines
19		19
20	//==============================================================================	20	//==============================================================================
21		21
22		22	#define USE_SAWTOOTH_TABLE 1
		23	#define USE_SQUARE_TABLE 1
		24	#define USE_TRIANGLE_TABLE 1
		25	#define USE_SHAPER_TABLE 1
		26
23	#define SINE_TABLE_SIZE 2048	27	#define SINE_TABLE_SIZE 2048
24	#define SAW_TABLE_SIZE 2048	28	#define SAW_TABLE_SIZE 2048
25	#define SQR_TABLE_SIZE 2048	29	#define SQR_TABLE_SIZE 2048

LEAF/Src/leaf-analysis.c+22−22

@@ -35,7 +35,7 @@ void tEnvelopeFollower_free(tEnvelopeFollower* const ef) · 34 unmodified lines
35	{	35	{
36	_tEnvelopeFollower* e = *ef;	36	_tEnvelopeFollower* e = *ef;
37		37
38	leaf_free(e);	38	leaf_free((char*)e);
39	}	39	}
40		40
41	void tEnvelopeFollower_initToPool (tEnvelopeFollower* const ef, float attackThreshold, float decayCoeff, tMempool* const mp)	41	void tEnvelopeFollower_initToPool (tEnvelopeFollower* const ef, float attackThreshold, float decayCoeff, tMempool* const mp)
@@ -53,7 +53,7 @@ void tEnvelopeFollower_freeFromPool (tEnvelopeFollower* const ef, tMempool* · 11 unmodified lines
53	_tMempool* m = *mp;	53	_tMempool* m = *mp;
54	_tEnvelopeFollower* e = *ef;	54	_tEnvelopeFollower* e = *ef;
55		55
56	mpool_free(e, m);	56	mpool_free((char*)e, m);
57	}	57	}
58		58
59	float tEnvelopeFollower_tick(tEnvelopeFollower* const ef, float x)	59	float tEnvelopeFollower_tick(tEnvelopeFollower* const ef, float x)
@@ -118,9 +118,9 @@ void tZeroCrossing_freeFromPool (tZeroCrossing* const zc, tMempool* const mp) · 58 unmodified lines
118	{	118	{
119	_tMempool* m = *mp;	119	_tMempool* m = *mp;
120	_tZeroCrossing* z = *zc;	120	_tZeroCrossing* z = *zc;
121	mpool_free(z->inBuffer, m);	121	mpool_free((char*)z->inBuffer, m);
122	mpool_free(z->countBuffer, m);	122	mpool_free((char*)z->countBuffer, m);
123	mpool_free(z, m);	123	mpool_free((char*)z, m);
124	}	124	}
125		125
126	//returns proportion of zero crossings within window size (0.0 would be none in window, 1.0 would be all zero crossings)	126	//returns proportion of zero crossings within window size (0.0 would be none in window, 1.0 would be all zero crossings)
@@ -197,7 +197,7 @@ void tPowerFollower_free(tPowerFollower* const pf) · 70 unmodified lines
197	{	197	{
198	_tPowerFollower* p = *pf;	198	_tPowerFollower* p = *pf;
199		199
200	leaf_free(p);	200	leaf_free((char*)p);
201	}	201	}
202		202
203	void tPowerFollower_initToPool (tPowerFollower* const pf, float factor, tMempool* const mp)	203	void tPowerFollower_initToPool (tPowerFollower* const pf, float factor, tMempool* const mp)
@@ -215,7 +215,7 @@ void tPowerFollower_freeFromPool (tPowerFollower* const pf, tMempool* const m · 11 unmodified lines
215	_tMempool* m = *mp;	215	_tMempool* m = *mp;
216	_tPowerFollower* p = *pf;	216	_tPowerFollower* p = *pf;
217		217
218	mpool_free(p, m);	218	mpool_free((char*)p, m);
219	}	219	}
220		220
221	int tPowerFollower_setFactor(tPowerFollower* const pf, float factor)	221	int tPowerFollower_setFactor(tPowerFollower* const pf, float factor)
@@ -295,7 +295,7 @@ void tEnvPD_free (tEnvPD* const xpd) · 73 unmodified lines
295	{	295	{
296	_tEnvPD* x = *xpd;	296	_tEnvPD* x = *xpd;
297		297
298	leaf_free(x);	298	leaf_free((char*)x);
299	}	299	}
300		300
301	void tEnvPD_initToPool (tEnvPD* const xpd, int ws, int hs, int bs, tMempool* const mp)	301	void tEnvPD_initToPool (tEnvPD* const xpd, int ws, int hs, int bs, tMempool* const mp)
@@ -346,7 +346,7 @@ void tEnvPD_freeFromPool (tEnvPD* const xpd, tMempool* const mp) · 44 unmodified lines
346	_tMempool* m = *mp;	346	_tMempool* m = *mp;
347	_tEnvPD* x = *xpd;	347	_tEnvPD* x = *xpd;
348		348
349	mpool_free(x, m);	349	mpool_free((char*)x, m);
350	}	350	}
351		351
352	float tEnvPD_tick (tEnvPD* const xpd)	352	float tEnvPD_tick (tEnvPD* const xpd)
@@ -412,7 +412,7 @@ void tAttackDetection_free(tAttackDetection* const ad) · 59 unmodified lines
412	{	412	{
413	_tAttackDetection* a = *ad;	413	_tAttackDetection* a = *ad;
414		414
415	leaf_free(a);	415	leaf_free((char*)a);
416	}	416	}
417		417
418	void tAttackDetection_initToPool (tAttackDetection* const ad, int blocksize, int atk, int rel, tMempool* const mp)	418	void tAttackDetection_initToPool (tAttackDetection* const ad, int blocksize, int atk, int rel, tMempool* const mp)
@@ -428,7 +428,7 @@ void tAttackDetection_freeFromPool (tAttackDetection* const ad, tMempool* c · 9 unmodified lines
428	_tMempool* m = *mp;	428	_tMempool* m = *mp;
429	_tAttackDetection* a = *ad;	429	_tAttackDetection* a = *ad;
430		430
431	mpool_free(a, m);	431	mpool_free((char*)a, m);
432	}	432	}
433		433
434	/*****Public Functions*********/	434	/*****Public Functions*********/
@@ -580,11 +580,11 @@ void tSNAC_free(tSNAC* const snac) · 145 unmodified lines
580	{	580	{
581	_tSNAC* s = *snac;	581	_tSNAC* s = *snac;
582		582
583	leaf_free(s->inputbuf);	583	leaf_free((char*)s->inputbuf);
584	leaf_free(s->processbuf);	584	leaf_free((char*)s->processbuf);
585	leaf_free(s->spectrumbuf);	585	leaf_free((char*)s->spectrumbuf);
586	leaf_free(s->biasbuf);	586	leaf_free((char*)s->biasbuf);
587	leaf_free(s);	587	leaf_free((char*)s);
588	}	588	}
589		589
590	void tSNAC_initToPool (tSNAC* const snac, int overlaparg, tMempool* const mp)	590	void tSNAC_initToPool (tSNAC* const snac, int overlaparg, tMempool* const mp)
@@ -614,11 +614,11 @@ void tSNAC_freeFromPool (tSNAC* const snac, tMempool* const mp) · 23 unmodified lines
614	_tMempool* m = *mp;	614	_tMempool* m = *mp;
615	_tSNAC* s = *snac;	615	_tSNAC* s = *snac;
616		616
617	mpool_free(s->inputbuf, m);	617	mpool_free((char*)s->inputbuf, m);
618	mpool_free(s->processbuf, m);	618	mpool_free((char*)s->processbuf, m);
619	mpool_free(s->spectrumbuf, m);	619	mpool_free((char*)s->spectrumbuf, m);
620	mpool_free(s->biasbuf, m);	620	mpool_free((char*)s->biasbuf, m);
621	mpool_free(s, m);	621	mpool_free((char*)s, m);
622	}	622	}
623		623
624	/******************************************************************************/	624	/******************************************************************************/
@@ -977,7 +977,7 @@ void tPeriodDetection_freeFromPool (tPeriodDetection* const pd, tMempoo · 352 unmodified lines
977		977
978	tEnvPD_freeFromPool(&p->env, mp);	978	tEnvPD_freeFromPool(&p->env, mp);
979	tSNAC_freeFromPool(&p->snac, mp);	979	tSNAC_freeFromPool(&p->snac, mp);
980	mpool_free(p, m);	980	mpool_free((char*)p, m);
981	}	981	}
982		982
983	float tPeriodDetection_tick (tPeriodDetection* pd, float sample)	983	float tPeriodDetection_tick (tPeriodDetection* pd, float sample)

LEAF/Src/leaf-delay.c+10−10

@@ -56,8 +56,8 @@ void tDelay_freeFromPool (tDelay* const dl, tMempool* const mp) · 55 unmodified lines
56	_tMempool* m = *mp;	56	_tMempool* m = *mp;
57	_tDelay* d = *dl;	57	_tDelay* d = *dl;
58		58
59	mpool_free(d->buff, m);	59	mpool_free((char*)d->buff, m);
60	mpool_free(d, m);	60	mpool_free((char*)d, m);
61	}	61	}
62		62
63	void tDelay_clear(tDelay* const dl)	63	void tDelay_clear(tDelay* const dl)
@@ -206,8 +206,8 @@ void tLinearDelay_freeFromPool(tLinearDelay* const dl, tMempool* const mp) · 142 unmodified lines
206	_tMempool* m = *mp;	206	_tMempool* m = *mp;
207	_tLinearDelay* d = *dl;	207	_tLinearDelay* d = *dl;
208		208
209	mpool_free(d->buff, m);	209	mpool_free((char*)d->buff, m);
210	mpool_free(d, m);	210	mpool_free((char*)d, m);
211	}	211	}
212		212
213	void tLinearDelay_clear(tLinearDelay* const dl)	213	void tLinearDelay_clear(tLinearDelay* const dl)
@@ -404,8 +404,8 @@ void tHermiteDelay_freeFromPool(tHermiteDelay* const dl, tMempool* const mp) · 190 unmodified lines
404	_tMempool* m = *mp;	404	_tMempool* m = *mp;
405	_tHermiteDelay* d = *dl;	405	_tHermiteDelay* d = *dl;
406		406
407	mpool_free(d->buff, m);	407	mpool_free((char*)d->buff, m);
408	mpool_free(d, m);	408	mpool_free((char*)d, m);
409	}	409	}
410		410
411		411
@@ -606,8 +606,8 @@ void tAllpassDelay_freeFromPool(tAllpassDelay* const dl, tMempool* const mp) · 194 unmodified lines
606	_tMempool* m = *mp;	606	_tMempool* m = *mp;
607	_tAllpassDelay* d = *dl;	607	_tAllpassDelay* d = *dl;
608		608
609	mpool_free(d->buff, m);	609	mpool_free((char*)d->buff, m);
610	mpool_free(d, m);	610	mpool_free((char*)d, m);
611	}	611	}
612		612
613	void tAllpassDelay_clear(tAllpassDelay* const dl)	613	void tAllpassDelay_clear(tAllpassDelay* const dl)
@@ -781,8 +781,8 @@ void tTapeDelay_freeFromPool(tTapeDelay* const dl, tMempool* const mp) · 167 unmodified lines
781	_tMempool* m = *mp;	781	_tMempool* m = *mp;
782	_tTapeDelay* d = *dl;	782	_tTapeDelay* d = *dl;
783		783
784	mpool_free(d->buff, m);	784	mpool_free((char*)d->buff, m);
785	mpool_free(d, m);	785	mpool_free((char*)d, m);
786	}	786	}
787		787
788	void tTapeDelay_clear(tTapeDelay* const dl)	788	void tTapeDelay_clear(tTapeDelay* const dl)

LEAF/Src/leaf-distortion.c+16−16

@@ -36,7 +36,7 @@ void tSampleReducer_free (tSampleReducer* const sr) · 35 unmodified lines
36	{	36	{
37	_tSampleReducer* s = *sr;	37	_tSampleReducer* s = *sr;
38		38
39	leaf_free(s);	39	leaf_free((char*)s);
40	}	40	}
41		41
42	void tSampleReducer_initToPool (tSampleReducer* const sr, tMempool* const mp)	42	void tSampleReducer_initToPool (tSampleReducer* const sr, tMempool* const mp)
@@ -54,7 +54,7 @@ void tSampleReducer_freeFromPool (tSampleReducer* const sr, tMempool* const m · 11 unmodified lines
54	_tMempool* m = *mp;	54	_tMempool* m = *mp;
55	_tSampleReducer* s = *sr;	55	_tSampleReducer* s = *sr;
56		56
57	mpool_free(s, m);	57	mpool_free((char*)s, m);
58	}	58	}
59		59
60	float tSampleReducer_tick(tSampleReducer* const sr, float input)	60	float tSampleReducer_tick(tSampleReducer* const sr, float input)
@@ -97,8 +97,8 @@ void tOversampler_init(tOversampler* const osr, int ratio, oBool extraQuality) · 36 unmodified lines
97	os->numTaps = __leaf_tablesize_firNumTaps[idx];	97	os->numTaps = __leaf_tablesize_firNumTaps[idx];
98	os->phaseLength = os->numTaps / os->ratio;	98	os->phaseLength = os->numTaps / os->ratio;
99	os->pCoeffs = (float*) __leaf_tableref_firCoeffs[idx];	99	os->pCoeffs = (float*) __leaf_tableref_firCoeffs[idx];
100	os->upState = leaf_alloc(sizeof(float) * os->numTaps * 2);	100	os->upState = (float) leaf_alloc(sizeof(float) os->numTaps * 2);
101	os->downState = leaf_alloc(sizeof(float) * os->numTaps * 2);	101	os->downState = (float) leaf_alloc(sizeof(float) os->numTaps * 2);
102	}	102	}
103	}	103	}
104		104
@@ -106,9 +106,9 @@ void tOversampler_free(tOversampler* const osr) · 1 unmodified line
106	{	106	{
107	_tOversampler* os = *osr;	107	_tOversampler* os = *osr;
108		108
109	leaf_free(os->upState);	109	leaf_free((char*)os->upState);
110	leaf_free(os->downState);	110	leaf_free((char*)os->downState);
111	leaf_free(os);	111	leaf_free((char*)os);
112	}	112	}
113		113
114	void tOversampler_initToPool (tOversampler* const osr, int ratio, oBool extraQuality, tMempool* const mp)	114	void tOversampler_initToPool (tOversampler* const osr, int ratio, oBool extraQuality, tMempool* const mp)
@@ -126,8 +126,8 @@ void tOversampler_initToPool (tOversampler* const osr, int ratio, oBool e · 11 unmodified lines
126	os->numTaps = __leaf_tablesize_firNumTaps[idx];	126	os->numTaps = __leaf_tablesize_firNumTaps[idx];
127	os->phaseLength = os->numTaps / os->ratio;	127	os->phaseLength = os->numTaps / os->ratio;
128	os->pCoeffs = (float*) __leaf_tableref_firCoeffs[idx];	128	os->pCoeffs = (float*) __leaf_tableref_firCoeffs[idx];
129	os->upState = mpool_alloc(sizeof(float) * os->numTaps * 2, m);	129	os->upState = (float) mpool_alloc(sizeof(float) os->numTaps * 2, m);
130	os->downState = mpool_alloc(sizeof(float) * os->numTaps * 2, m);	130	os->downState = (float) mpool_alloc(sizeof(float) os->numTaps * 2, m);
131	}	131	}
132	}	132	}
133		133
@@ -136,9 +136,9 @@ void tOversampler_freeFromPool (tOversampler* const osr, tMempool* const mp · 2 unmodified lines
136	_tMempool* m = *mp;	136	_tMempool* m = *mp;
137	_tOversampler* os = *osr;	137	_tOversampler* os = *osr;
138		138
139	mpool_free(os->upState, m);	139	mpool_free((char*)os->upState, m);
140	mpool_free(os->downState, m);	140	mpool_free((char*)os->downState, m);
141	mpool_free(os, m);	141	mpool_free((char*)os, m);
142	}	142	}
143		143
144	float tOversampler_tick(tOversampler* const osr, float input, float (*effectTick)(float))	144	float tOversampler_tick(tOversampler* const osr, float input, float (*effectTick)(float))
@@ -357,7 +357,7 @@ void tLockhartWavefolder_free(tLockhartWavefolder* const wf) · 212 unmodified lines
357	{	357	{
358	_tLockhartWavefolder* w = *wf;	358	_tLockhartWavefolder* w = *wf;
359		359
360	leaf_free(w);	360	leaf_free((char*)w);
361	}	361	}
362		362
363	void tLockhartWavefolder_initToPool (tLockhartWavefolder* const wf, tMempool* const mp)	363	void tLockhartWavefolder_initToPool (tLockhartWavefolder* const wf, tMempool* const mp)
@@ -409,7 +409,7 @@ void tLockhartWavefolder_freeFromPool (tLockhartWavefolder* const wf, tMempoo · 45 unmodified lines
409	_tMempool* m = *mp;	409	_tMempool* m = *mp;
410	_tLockhartWavefolder* w = *wf;	410	_tLockhartWavefolder* w = *wf;
411		411
412	mpool_free(w, m);	412	mpool_free((char*)w, m);
413	}	413	}
414		414
415		415
@@ -613,7 +613,7 @@ void tCrusher_free (tCrusher* const cr) · 197 unmodified lines
613	{	613	{
614	_tCrusher* c = *cr;	614	_tCrusher* c = *cr;
615	tSampleReducer_free(&c->sReducer);	615	tSampleReducer_free(&c->sReducer);
616	leaf_free(c);	616	leaf_free((char*)c);
617	}	617	}
618		618
619	void tCrusher_initToPool (tCrusher* const cr, tMempool* const mp)	619	void tCrusher_initToPool (tCrusher* const cr, tMempool* const mp)
@@ -634,7 +634,7 @@ void tCrusher_freeFromPool (tCrusher* const cr, tMempool* const mp) · 14 unmodified lines
634	_tMempool* m = *mp;	634	_tMempool* m = *mp;
635	_tCrusher* c = *cr;	635	_tCrusher* c = *cr;
636	tSampleReducer_freeFromPool(&c->sReducer, mp);	636	tSampleReducer_freeFromPool(&c->sReducer, mp);
637	mpool_free(c, m);	637	mpool_free((char*)c, m);
638	}	638	}
639		639
640	float tCrusher_tick (tCrusher* const cr, float input)	640	float tCrusher_tick (tCrusher* const cr, float input)

LEAF/Src/leaf-dynamics.c+5−5

@@ -60,7 +60,7 @@ void tCompressor_free(tCompressor* const comp) · 59 unmodified lines
60	{	60	{
61	_tCompressor* c = *comp;	61	_tCompressor* c = *comp;
62		62
63	leaf_free(c);	63	leaf_free((char*)c);
64	}	64	}
65		65
66	void tCompressor_initToPool (tCompressor* const comp, tMempool* const mp)	66	void tCompressor_initToPool (tCompressor* const comp, tMempool* const mp)
@@ -84,7 +84,7 @@ void tCompressor_freeFromPool(tCompressor* const comp, tMempool* const mp) · 17 unmodified lines
84	_tMempool* m = *mp;	84	_tMempool* m = *mp;
85	_tCompressor* c = *comp;	85	_tCompressor* c = *comp;
86		86
87	mpool_free(c, m);	87	mpool_free((char*)c, m);
88	}	88	}
89		89
90	float tCompressor_tick(tCompressor* const comp, float in)	90	float tCompressor_tick(tCompressor* const comp, float in)
@@ -154,7 +154,7 @@ void tFeedbackLeveler_free(tFeedbackLeveler* const fb) · 63 unmodified lines
154	_tFeedbackLeveler* p = *fb;	154	_tFeedbackLeveler* p = *fb;
155		155
156	tPowerFollower_free(&p->pwrFlw);	156	tPowerFollower_free(&p->pwrFlw);
157	leaf_free(p);	157	leaf_free((char*)p);
158	}	158	}
159		159
160	void tFeedbackLeveler_initToPool (tFeedbackLeveler* const fb, float targetLevel, float factor, float strength, int mode, tMempool* const mp)	160	void tFeedbackLeveler_initToPool (tFeedbackLeveler* const fb, float targetLevel, float factor, float strength, int mode, tMempool* const mp)
@@ -175,7 +175,7 @@ void tFeedbackLeveler_freeFromPool (tFeedbackLeveler* const fb, tMempool* c · 14 unmodified lines
175	_tFeedbackLeveler* p = *fb;	175	_tFeedbackLeveler* p = *fb;
176		176
177	tPowerFollower_freeFromPool(&p->pwrFlw, mp);	177	tPowerFollower_freeFromPool(&p->pwrFlw, mp);
178	mpool_free(p, m);	178	mpool_free((char*)p, m);
179	}	179	}
180		180
181	void tFeedbackLeveler_setStrength(tFeedbackLeveler* const fb, float strength)	181	void tFeedbackLeveler_setStrength(tFeedbackLeveler* const fb, float strength)
@@ -247,7 +247,7 @@ void tThreshold_freeFromPool(tThreshold* const th, tMempool* const mp) · 65 unmodified lines
247	_tMempool* m = *mp;	247	_tMempool* m = *mp;
248	_tThreshold* t = *th;	248	_tThreshold* t = *th;
249		249
250	mpool_free(t, m);	250	mpool_free((char*)t, m);
251	}	251	}
252		252
253	int tThreshold_tick(tThreshold* const th, float in)	253	int tThreshold_tick(tThreshold* const th, float in)

LEAF/Src/leaf-effects.c+65−65

@@ -52,13 +52,13 @@ void tTalkbox_free(tTalkbox* const voc) · 51 unmodified lines
52	{	52	{
53	_tTalkbox* v = *voc;	53	_tTalkbox* v = *voc;
54		54
55	leaf_free(v->buf1);	55	leaf_free((char*)v->buf1);
56	leaf_free(v->buf0);	56	leaf_free((char*)v->buf0);
57	leaf_free(v->window);	57	leaf_free((char*)v->window);
58	leaf_free(v->car1);	58	leaf_free((char*)v->car1);
59	leaf_free(v->car0);	59	leaf_free((char*)v->car0);
60		60
61	leaf_free(v);	61	leaf_free((char*)v);
62	}	62	}
63		63
64	void tTalkbox_initToPool (tTalkbox* const voc, int bufsize, tMempool* const mp)	64	void tTalkbox_initToPool (tTalkbox* const voc, int bufsize, tMempool* const mp)
@@ -89,13 +89,13 @@ void tTalkbox_freeFromPool (tTalkbox* const voc, tMempool* const mp) · 24 unmodified lines
89	_tMempool* m = *mp;	89	_tMempool* m = *mp;
90	_tTalkbox* v = *voc;	90	_tTalkbox* v = *voc;
91		91
92	mpool_free(v->buf1, m);	92	mpool_free((char*)v->buf1, m);
93	mpool_free(v->buf0, m);	93	mpool_free((char*)v->buf0, m);
94	mpool_free(v->window, m);	94	mpool_free((char*)v->window, m);
95	mpool_free(v->car1, m);	95	mpool_free((char*)v->car1, m);
96	mpool_free(v->car0, m);	96	mpool_free((char*)v->car0, m);
97		97
98	mpool_free(v, m);	98	mpool_free((char*)v, m);
99	}	99	}
100		100
101	void tTalkbox_update(tTalkbox* const voc) ///update internal parameters...	101	void tTalkbox_update(tTalkbox* const voc) ///update internal parameters...
@@ -373,7 +373,7 @@ void tVocoder_free (tVocoder* const voc) · 271 unmodified lines
373	{	373	{
374	_tVocoder* v = *voc;	374	_tVocoder* v = *voc;
375		375
376	leaf_free(v);	376	leaf_free((char*)v);
377	}	377	}
378		378
379	void tVocoder_initToPool (tVocoder* const voc, tMempool* const mp)	379	void tVocoder_initToPool (tVocoder* const voc, tMempool* const mp)
@@ -398,7 +398,7 @@ void tVocoder_freeFromPool (tVocoder* const voc, tMempool* const mp) · 18 unmodified lines
398	_tMempool* m = *mp;	398	_tMempool* m = *mp;
399	_tVocoder* v = *voc;	399	_tVocoder* v = *voc;
400		400
401	mpool_free(v, m);	401	mpool_free((char*)v, m);
402	}	402	}
403		403
404	void tVocoder_update (tVocoder* const voc)	404	void tVocoder_update (tVocoder* const voc)
@@ -591,7 +591,7 @@ void tRosenbergGlottalPulse_freeFromPool (tRosenbergGlottalPulse* const gp, · 186 unmodified lines
591	{	591	{
592	_tMempool* m = *mp;	592	_tMempool* m = *mp;
593	_tRosenbergGlottalPulse* g = *gp;	593	_tRosenbergGlottalPulse* g = *gp;
594	mpool_free(g, m);	594	mpool_free((char*)g, m);
595	}	595	}
596		596
597	float tRosenbergGlottalPulse_tick (tRosenbergGlottalPulse* const gp)	597	float tRosenbergGlottalPulse_tick (tRosenbergGlottalPulse* const gp)
@@ -675,8 +675,8 @@ void tSOLAD_free(tSOLAD* const wp) · 77 unmodified lines
675	{	675	{
676	_tSOLAD* w = *wp;	676	_tSOLAD* w = *wp;
677		677
678	leaf_free(w->delaybuf);	678	leaf_free((char*)w->delaybuf);
679	leaf_free(w);	679	leaf_free((char*)w);
680	}	680	}
681		681
682	void tSOLAD_initToPool (tSOLAD* const wp, tMempool* const mp)	682	void tSOLAD_initToPool (tSOLAD* const wp, tMempool* const mp)
@@ -696,8 +696,8 @@ void tSOLAD_freeFromPool (tSOLAD* const wp, tMempool* const mp) · 13 unmodified lines
696	_tMempool* m = *mp;	696	_tMempool* m = *mp;
697	_tSOLAD* w = *wp;	697	_tSOLAD* w = *wp;
698		698
699	mpool_free(w->delaybuf, m);	699	mpool_free((char*)w->delaybuf, m);
700	mpool_free(w, m);	700	mpool_free((char*)w, m);
701	}	701	}
702		702
703	// send one block of input samples, receive one block of output samples	703	// send one block of input samples, receive one block of output samples
@@ -1059,7 +1059,7 @@ void tPitchShift_free(tPitchShift* const psr) · 355 unmodified lines
1059		1059
1060	tSOLAD_free(&ps->sola);	1060	tSOLAD_free(&ps->sola);
1061	tHighpass_free(&ps->hp);	1061	tHighpass_free(&ps->hp);
1062	leaf_free(ps);	1062	leaf_free((char*)ps);
1063	}	1063	}
1064		1064
1065	void tPitchShift_initToPool (tPitchShift* const psr, tPeriodDetection* const pd, float* out, int bufSize, tMempool* const mp)	1065	void tPitchShift_initToPool (tPitchShift* const psr, tPeriodDetection* const pd, float* out, int bufSize, tMempool* const mp)
@@ -1095,7 +1095,7 @@ void tPitchShift_freeFromPool (tPitchShift* const psr, tMempool* const mp) · 29 unmodified lines
1095		1095
1096	tSOLAD_freeFromPool(&ps->sola, mp);	1096	tSOLAD_freeFromPool(&ps->sola, mp);
1097	tHighpass_freeFromPool(&ps->hp, mp);	1097	tHighpass_freeFromPool(&ps->hp, mp);
1098	mpool_free(ps, m);	1098	mpool_free((char*)ps, m);
1099	}	1099	}
1100		1100
1101	void tPitchShift_setPitchFactor(tPitchShift* psr, float pf)	1101	void tPitchShift_setPitchFactor(tPitchShift* psr, float pf)
@@ -1269,14 +1269,14 @@ void tRetune_freeFromPool (tRetune* const rt, tMempool* const mp) · 167 unmodified lines
1269	for (int i = 0; i < r->numVoices; ++i)	1269	for (int i = 0; i < r->numVoices; ++i)
1270	{	1270	{
1271	tPitchShift_freeFromPool(&r->ps[i], mp);	1271	tPitchShift_freeFromPool(&r->ps[i], mp);
1272	mpool_free(r->outBuffers[i], m);	1272	mpool_free((char*)r->outBuffers[i], m);
1273	}	1273	}
1274	mpool_free(r->tickOutput, m);	1274	mpool_free((char*)r->tickOutput, m);
1275	mpool_free(r->pitchFactor, m);	1275	mpool_free((char*)r->pitchFactor, m);
1276	mpool_free(r->ps, m);	1276	mpool_free((char*)r->ps, m);
1277	mpool_free(r->inBuffer, m);	1277	mpool_free((char*)r->inBuffer, m);
1278	mpool_free(r->outBuffers, m);	1278	mpool_free((char*)r->outBuffers, m);
1279	mpool_free(r, m);	1279	mpool_free((char*)r, m);
1280	}	1280	}
1281		1281
1282	float* tRetune_tick(tRetune* const rt, float sample)	1282	float* tRetune_tick(tRetune* const rt, float sample)
@@ -1300,12 +1300,12 @@ void tRetune_setNumVoices(tRetune* const rt, int numVoices) · 17 unmodified lines
1300	for (int i = 0; i < r->numVoices; ++i)	1300	for (int i = 0; i < r->numVoices; ++i)
1301	{	1301	{
1302	tPitchShift_free(&r->ps[i]);	1302	tPitchShift_free(&r->ps[i]);
1303	leaf_free(r->outBuffers[i]);	1303	leaf_free((char*)r->outBuffers[i]);
1304	}	1304	}
1305	leaf_free(r->tickOutput);	1305	leaf_free((char*)r->tickOutput);
1306	leaf_free(r->pitchFactor);	1306	leaf_free((char*)r->pitchFactor);
1307	leaf_free(r->ps);	1307	leaf_free((char*)r->ps);
1308	leaf_free(r->outBuffers);	1308	leaf_free((char*)r->outBuffers);
1309		1309
1310	r->numVoices = numVoices;	1310	r->numVoices = numVoices;
1311		1311
@@ -1442,14 +1442,14 @@ void tAutotune_freeFromPool (tAutotune* const rt, tMempool* const mp) · 130 unmodified lines
1442	for (int i = 0; i < r->numVoices; ++i)	1442	for (int i = 0; i < r->numVoices; ++i)
1443	{	1443	{
1444	tPitchShift_freeFromPool(&r->ps[i], mp);	1444	tPitchShift_freeFromPool(&r->ps[i], mp);
1445	mpool_free(r->outBuffers[i], m);	1445	mpool_free((char*)r->outBuffers[i], m);
1446	}	1446	}
1447	mpool_free(r->tickOutput, m);	1447	mpool_free((char*)r->tickOutput, m);
1448	mpool_free(r->freq, m);	1448	mpool_free((char*)r->freq, m);
1449	mpool_free(r->ps, m);	1449	mpool_free((char*)r->ps, m);
1450	mpool_free(r->inBuffer, m);	1450	mpool_free((char*)r->inBuffer, m);
1451	mpool_free(r->outBuffers, m);	1451	mpool_free((char*)r->outBuffers, m);
1452	mpool_free(r, m);	1452	mpool_free((char*)r, m);
1453	}	1453	}
1454		1454
1455	float* tAutotune_tick(tAutotune* const rt, float sample)	1455	float* tAutotune_tick(tAutotune* const rt, float sample)
@@ -1477,12 +1477,12 @@ void tAutotune_setNumVoices(tAutotune* const rt, int numVoices) · 21 unmodified lines
1477	for (int i = 0; i < r->numVoices; ++i)	1477	for (int i = 0; i < r->numVoices; ++i)
1478	{	1478	{
1479	tPitchShift_free(&r->ps[i]);	1479	tPitchShift_free(&r->ps[i]);
1480	leaf_free(r->outBuffers[i]);	1480	leaf_free((char*)r->outBuffers[i]);
1481	}	1481	}
1482	leaf_free(r->tickOutput);	1482	leaf_free((char*)r->tickOutput);
1483	leaf_free(r->freq);	1483	leaf_free((char*)r->freq);
1484	leaf_free(r->ps);	1484	leaf_free((char*)r->ps);
1485	leaf_free(r->outBuffers);	1485	leaf_free((char*)r->outBuffers);
1486		1486
1487	r->numVoices = numVoices;	1487	r->numVoices = numVoices;
1488		1488
@@ -1611,20 +1611,20 @@ void tFormantShifter_free(tFormantShifter* const fsr) · 122 unmodified lines
1611	{	1611	{
1612	_tFormantShifter* fs = *fsr;	1612	_tFormantShifter* fs = *fsr;
1613		1613
1614	leaf_free(fs->fk);	1614	leaf_free((char*)fs->fk);
1615	leaf_free(fs->fb);	1615	leaf_free((char*)fs->fb);
1616	leaf_free(fs->fc);	1616	leaf_free((char*)fs->fc);
1617	leaf_free(fs->frb);	1617	leaf_free((char*)fs->frb);
1618	leaf_free(fs->frc);	1618	leaf_free((char*)fs->frc);
1619	leaf_free(fs->fsig);	1619	leaf_free((char*)fs->fsig);
1620	leaf_free(fs->fsmooth);	1620	leaf_free((char*)fs->fsmooth);
1621	leaf_free(fs->ftvec);	1621	leaf_free((char*)fs->ftvec);
1622	leaf_free(fs->fbuff);	1622	leaf_free((char*)fs->fbuff);
1623	tHighpass_free(&fs->hp);	1623	tHighpass_free(&fs->hp);
1624	tHighpass_free(&fs->hp2);	1624	tHighpass_free(&fs->hp2);
1625	tFeedbackLeveler_free(&fs->fbl1);	1625	tFeedbackLeveler_free(&fs->fbl1);
1626	tFeedbackLeveler_free(&fs->fbl2);	1626	tFeedbackLeveler_free(&fs->fbl2);
1627	leaf_free(fs);	1627	leaf_free((char*)fs);
1628	}	1628	}
1629		1629
1630	void tFormantShifter_initToPool (tFormantShifter* const fsr, int order, tMempool* const mp)	1630	void tFormantShifter_initToPool (tFormantShifter* const fsr, int order, tMempool* const mp)
@@ -1666,20 +1666,20 @@ void tFormantShifter_freeFromPool (tFormantShifter* const fsr, tMempool* c · 35 unmodified lines
1666	_tMempool* m = *mp;	1666	_tMempool* m = *mp;
1667	_tFormantShifter* fs = *fsr;	1667	_tFormantShifter* fs = *fsr;
1668		1668
1669	mpool_free(fs->fk, m);	1669	mpool_free((char*)fs->fk, m);
1670	mpool_free(fs->fb, m);	1670	mpool_free((char*)fs->fb, m);
1671	mpool_free(fs->fc, m);	1671	mpool_free((char*)fs->fc, m);
1672	mpool_free(fs->frb, m);	1672	mpool_free((char*)fs->frb, m);
1673	mpool_free(fs->frc, m);	1673	mpool_free((char*)fs->frc, m);
1674	mpool_free(fs->fsig, m);	1674	mpool_free((char*)fs->fsig, m);
1675	mpool_free(fs->fsmooth, m);	1675	mpool_free((char*)fs->fsmooth, m);
1676	mpool_free(fs->ftvec, m);	1676	mpool_free((char*)fs->ftvec, m);
1677	mpool_free(fs->fbuff, m);	1677	mpool_free((char*)fs->fbuff, m);
1678	tHighpass_freeFromPool(&fs->hp, mp);	1678	tHighpass_freeFromPool(&fs->hp, mp);
1679	tHighpass_freeFromPool(&fs->hp2, mp);	1679	tHighpass_freeFromPool(&fs->hp2, mp);
1680	tFeedbackLeveler_freeFromPool(&fs->fbl1, mp);	1680	tFeedbackLeveler_freeFromPool(&fs->fbl1, mp);
1681	tFeedbackLeveler_freeFromPool(&fs->fbl2, mp);	1681	tFeedbackLeveler_freeFromPool(&fs->fbl2, mp);
1682	mpool_free(fs, m);	1682	mpool_free((char*)fs, m);
1683	}	1683	}
1684		1684
1685	float tFormantShifter_tick(tFormantShifter* const fsr, float in)	1685	float tFormantShifter_tick(tFormantShifter* const fsr, float in)

LEAF/Src/leaf-electrical.c+2−2

@@ -175,7 +175,7 @@ void tWDF_free(tWDF* const wdf) · 174 unmodified lines
175	{	175	{
176	_tWDF* r = *wdf;	176	_tWDF* r = *wdf;
177		177
178	leaf_free(r);	178	leaf_free((char*)r);
179	}	179	}
180		180
181	void tWDF_initToPool (tWDF* const wdf, WDFComponentType type, float value, tWDF* const rL, tWDF* const rR, tMempool* const mp)	181	void tWDF_initToPool (tWDF* const wdf, WDFComponentType type, float value, tWDF* const rL, tWDF* const rR, tMempool* const mp)
@@ -191,7 +191,7 @@ void tWDF_freeFromPool (tWDF* const wdf, tMempool* const mp) · 9 unmodified lines
191	_tMempool* m = *mp;	191	_tMempool* m = *mp;
192	_tWDF* r = *wdf;	192	_tWDF* r = *wdf;
193		193
194	mpool_free(r, m);	194	mpool_free((char*)r, m);
195	}	195	}
196		196
197	float tWDF_tick(tWDF* const wdf, float sample, tWDF* const outputPoint, uint8_t paramsChanged)	197	float tWDF_tick(tWDF* const wdf, float sample, tWDF* const outputPoint, uint8_t paramsChanged)

LEAF/Src/leaf-envelopes.c+15−15

@@ -24,7 +24,7 @@ · 23 unmodified lines
24	#endif	24	#endif
25		25
26	// ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ Envelope ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ //	26	// ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ Envelope ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ //
27	void tEnvelope_init(tEnvelope* const envlp, float attack, float decay, oBool loop)	27	void tEnvelope_init(tEnvelope* const envlp, float attack, float decay, int loop)
28	{	28	{
29	_tEnvelope* env = envlp = (_tEnvelope) leaf_alloc(sizeof(_tEnvelope));	29	_tEnvelope* env = envlp = (_tEnvelope) leaf_alloc(sizeof(_tEnvelope));
30		30
@@ -67,10 +67,10 @@ void tEnvelope_init(tEnvelope* const envlp, float attack, float decay, oBool · 36 unmodified lines
67	void tEnvelope_free(tEnvelope* const envlp)	67	void tEnvelope_free(tEnvelope* const envlp)
68	{	68	{
69	_tEnvelope* env = *envlp;	69	_tEnvelope* env = *envlp;
70	leaf_free(env);	70	leaf_free((char*)env);
71	}	71	}
72		72
73	void tEnvelope_initToPool (tEnvelope* const envlp, float attack, float decay, oBool loop, tMempool* const mp)	73	void tEnvelope_initToPool (tEnvelope* const envlp, float attack, float decay, int loop, tMempool* const mp)
74	{	74	{
75	_tMempool* m = *mp;	75	_tMempool* m = *mp;
76	_tEnvelope* env = envlp = (_tEnvelope) mpool_alloc(sizeof(_tEnvelope), m);	76	_tEnvelope* env = envlp = (_tEnvelope) mpool_alloc(sizeof(_tEnvelope), m);
@@ -115,7 +115,7 @@ void tEnvelope_freeFromPool (tEnvelope* const envlp, tMempool* const mp) · 38 unmodified lines
115	{	115	{
116	_tMempool* m = *mp;	116	_tMempool* m = *mp;
117	_tEnvelope* env = *envlp;	117	_tEnvelope* env = *envlp;
118	mpool_free(env, m);	118	mpool_free((char*)env, m);
119	}	119	}
120		120
121	void tEnvelope_setAttack(tEnvelope* const envlp, float attack)	121	void tEnvelope_setAttack(tEnvelope* const envlp, float attack)
@@ -152,7 +152,7 @@ void tEnvelope_setDecay(tEnvelope* const envlp, float decay) · 30 unmodified lines
152	env->decayInc = env->inc_buff[decayIndex];	152	env->decayInc = env->inc_buff[decayIndex];
153	}	153	}
154		154
155	void tEnvelope_loop(tEnvelope* const envlp, oBool loop)	155	void tEnvelope_loop(tEnvelope* const envlp, int loop)
156	{	156	{
157	_tEnvelope* env = *envlp;	157	_tEnvelope* env = *envlp;
158	env->loop = loop;	158	env->loop = loop;
@@ -331,7 +331,7 @@ void tADSR_freeFromPool (tADSR* const adsrenv, tMempool* const mp) · 172 unmodified lines
331	{	331	{
332	_tMempool* m = *mp;	332	_tMempool* m = *mp;
333	_tADSR* adsr = *adsrenv;	333	_tADSR* adsr = *adsrenv;
334	mpool_free(adsr, m);	334	mpool_free((char*)adsr, m);
335	}	335	}
336		336
337	void tADSR_setAttack(tADSR* const adsrenv, float attack)	337	void tADSR_setAttack(tADSR* const adsrenv, float attack)
@@ -587,7 +587,7 @@ void tADSR2_freeFromPool (tADSR2* const adsrenv, tMempool* const mp) · 249 unmodified lines
587	{	587	{
588	_tMempool* m = *mp;	588	_tMempool* m = *mp;
589	_tADSR2* adsr = *adsrenv;	589	_tADSR2* adsr = *adsrenv;
590	mpool_free(adsr, m);	590	mpool_free((char*)adsr, m);
591	}	591	}
592		592
593	void tADSR2_setAttack(tADSR2* const adsrenv, float attack)	593	void tADSR2_setAttack(tADSR2* const adsrenv, float attack)
@@ -745,7 +745,7 @@ void tADSR3_freeFromPool (tADSR3* const adsrenv, tMempool* const mp) · 151 unmodified lines
745	{	745	{
746	_tMempool* m = *mp;	746	_tMempool* m = *mp;
747	_tADSR3* adsr = *adsrenv;	747	_tADSR3* adsr = *adsrenv;
748	mpool_free(adsr, m);	748	mpool_free((char*)adsr, m);
749	}	749	}
750		750
751	void tADSR3_setAttack(tADSR3* const adsrenv, float attack)	751	void tADSR3_setAttack(tADSR3* const adsrenv, float attack)
@@ -903,7 +903,7 @@ void tADSR4_freeFromPool (tADSR4* const adsrenv, tMempool* const mp) · 151 unmodified lines
903	{	903	{
904	_tMempool* m = *mp;	904	_tMempool* m = *mp;
905	_tADSR4* adsr = *adsrenv;	905	_tADSR4* adsr = *adsrenv;
906	mpool_free(adsr, m);	906	mpool_free((char*)adsr, m);
907	}	907	}
908		908
909	void tADSR4_setAttack(tADSR4* const adsrenv, float attack)	909	void tADSR4_setAttack(tADSR4* const adsrenv, float attack)
@@ -1227,7 +1227,7 @@ void tRamp_free(tRamp* const r) · 317 unmodified lines
1227	{	1227	{
1228	_tRamp* ramp = *r;	1228	_tRamp* ramp = *r;
1229		1229
1230	leaf_free(ramp);	1230	leaf_free((char*)ramp);
1231	}	1231	}
1232		1232
1233	void tRamp_initToPool (tRamp* const r, float time, int samples_per_tick, tMempool* const mp)	1233	void tRamp_initToPool (tRamp* const r, float time, int samples_per_tick, tMempool* const mp)
@@ -1258,7 +1258,7 @@ void tRamp_freeFromPool (tRamp* const r, tMempool* const mp) · 24 unmodified lines
1258	_tMempool* m = *mp;	1258	_tMempool* m = *mp;
1259	_tRamp* ramp = *r;	1259	_tRamp* ramp = *r;
1260		1260
1261	mpool_free(ramp, m);	1261	mpool_free((char*)ramp, m);
1262	}	1262	}
1263		1263
1264	void tRamp_setTime(tRamp* const ramp, float time)	1264	void tRamp_setTime(tRamp* const ramp, float time)
@@ -1372,7 +1372,7 @@ void tRampUpDown_freeFromPool (tRampUpDown* const r, tMempool* const mp) · 107 unmodified lines
1372	_tMempool* m = *mp;	1372	_tMempool* m = *mp;
1373	_tRampUpDown* ramp = *r;	1373	_tRampUpDown* ramp = *r;
1374		1374
1375	mpool_free(ramp, m);	1375	mpool_free((char*)ramp, m);
1376	}	1376	}
1377		1377
1378	void tRampUpDown_setUpTime(tRampUpDown* const ramp, float upTime)	1378	void tRampUpDown_setUpTime(tRampUpDown* const ramp, float upTime)
@@ -1484,7 +1484,7 @@ void tExpSmooth_free(tExpSmooth* const expsmooth) · 105 unmodified lines
1484	{	1484	{
1485	_tExpSmooth* smooth = *expsmooth;	1485	_tExpSmooth* smooth = *expsmooth;
1486		1486
1487	leaf_free(smooth);	1487	leaf_free((char*)smooth);
1488	}	1488	}
1489		1489
1490	void tExpSmooth_initToPool (tExpSmooth* const expsmooth, float val, float factor, tMempool* const mp)	1490	void tExpSmooth_initToPool (tExpSmooth* const expsmooth, float val, float factor, tMempool* const mp)
@@ -1505,7 +1505,7 @@ void tExpSmooth_freeFromPool (tExpSmooth* const expsmooth, tMempool* const mp · 14 unmodified lines
1505	_tMempool* m = *mp;	1505	_tMempool* m = *mp;
1506	_tExpSmooth* smooth = *expsmooth;	1506	_tExpSmooth* smooth = *expsmooth;
1507		1507
1508	mpool_free(smooth, m);	1508	mpool_free((char*)smooth, m);
1509	}	1509	}
1510		1510
1511	void tExpSmooth_setFactor(tExpSmooth* const expsmooth, float factor)	1511	void tExpSmooth_setFactor(tExpSmooth* const expsmooth, float factor)
@@ -1588,7 +1588,7 @@ void tSlide_freeFromPool (tSlide* const sl, tMempool* const mp) · 76 unmodified lines
1588	_tMempool* m = *mp;	1588	_tMempool* m = *mp;
1589	_tSlide* s = *sl;	1589	_tSlide* s = *sl;
1590		1590
1591	mpool_free(s, m);	1591	mpool_free((char*)s, m);
1592	}	1592	}
1593		1593
1594	float tSlide_tick(tSlide* const sl, float in)	1594	float tSlide_tick(tSlide* const sl, float in)

LEAF/Src/leaf-filters.c+30−30

@@ -37,7 +37,7 @@ void tAllpass_free(tAllpass* const ft) · 36 unmodified lines
37	_tAllpass* f = *ft;	37	_tAllpass* f = *ft;
38		38
39	tLinearDelay_free(&f->delay);	39	tLinearDelay_free(&f->delay);
40	leaf_free(f);	40	leaf_free((char*)f);
41	}	41	}
42		42
43	void tAllpass_initToPool (tAllpass* const ft, float initDelay, uint32_t maxDelay, tMempool* const mp)	43	void tAllpass_initToPool (tAllpass* const ft, float initDelay, uint32_t maxDelay, tMempool* const mp)
@@ -58,7 +58,7 @@ void tAllpass_freeFromPool (tAllpass* const ft, tMempool* const mp) · 14 unmodified lines
58	_tAllpass* f = *ft;	58	_tAllpass* f = *ft;
59		59
60	tLinearDelay_freeFromPool(&f->delay, mp);	60	tLinearDelay_freeFromPool(&f->delay, mp);
61	mpool_free(f, m);	61	mpool_free((char*)f, m);
62	}	62	}
63		63
64	void tAllpass_setDelay(tAllpass* const ft, float delay)	64	void tAllpass_setDelay(tAllpass* const ft, float delay)
@@ -106,7 +106,7 @@ void tOnePole_free(tOnePole* const ft) · 41 unmodified lines
106	{	106	{
107	_tOnePole* f = *ft;	107	_tOnePole* f = *ft;
108		108
109	leaf_free(f);	109	leaf_free((char*)f);
110	}	110	}
111		111
112	void tOnePole_initToPool (tOnePole* const ft, float freq, tMempool* const mp)	112	void tOnePole_initToPool (tOnePole* const ft, float freq, tMempool* const mp)
@@ -128,7 +128,7 @@ void tOnePole_freeFromPool (tOnePole* const ft, tMempool* const mp) · 15 unmodified lines
128	_tMempool* m = *mp;	128	_tMempool* m = *mp;
129	_tOnePole* f = *ft;	129	_tOnePole* f = *ft;
130		130
131	mpool_free(f, m);	131	mpool_free((char*)f, m);
132	}	132	}
133		133
134	void tOnePole_setB0(tOnePole* const ft, float b0)	134	void tOnePole_setB0(tOnePole* const ft, float b0)
@@ -209,7 +209,7 @@ void tTwoPole_free(tTwoPole* const ft) · 74 unmodified lines
209	{	209	{
210	_tTwoPole* f = *ft;	210	_tTwoPole* f = *ft;
211		211
212	leaf_free(f);	212	leaf_free((char*)f);
213	}	213	}
214		214
215	void tTwoPole_initToPool (tTwoPole* const ft, tMempool* const mp)	215	void tTwoPole_initToPool (tTwoPole* const ft, tMempool* const mp)
@@ -230,7 +230,7 @@ void tTwoPole_freeFromPool (tTwoPole* const ft, tMempool* const mp) · 14 unmodified lines
230	_tMempool* m = *mp;	230	_tMempool* m = *mp;
231	_tTwoPole* f = *ft;	231	_tTwoPole* f = *ft;
232		232
233	mpool_free(f, m);	233	mpool_free((char*)f, m);
234	}	234	}
235		235
236	float tTwoPole_tick(tTwoPole* const ft, float input)	236	float tTwoPole_tick(tTwoPole* const ft, float input)
@@ -335,7 +335,7 @@ void tOneZero_free(tOneZero* const ft) · 98 unmodified lines
335	{	335	{
336	_tOneZero* f = *ft;	336	_tOneZero* f = *ft;
337		337
338	leaf_free(f);	338	leaf_free((char*)f);
339	}	339	}
340		340
341	void tOneZero_initToPool (tOneZero* const ft, float theZero, tMempool* const mp)	341	void tOneZero_initToPool (tOneZero* const ft, float theZero, tMempool* const mp)
@@ -354,7 +354,7 @@ void tOneZero_freeFromPool (tOneZero* const ft, tMempool* const mp) · 12 unmodified lines
354	_tMempool* m = *mp;	354	_tMempool* m = *mp;
355	_tOneZero* f = *ft;	355	_tOneZero* f = *ft;
356		356
357	mpool_free(f, m);	357	mpool_free((char*)f, m);
358	}	358	}
359		359
360	float tOneZero_tick(tOneZero* const ft, float input)	360	float tOneZero_tick(tOneZero* const ft, float input)
@@ -450,7 +450,7 @@ void tTwoZero_free(tTwoZero* const ft) · 89 unmodified lines
450	{	450	{
451	_tTwoZero* f = *ft;	451	_tTwoZero* f = *ft;
452		452
453	leaf_free(f);	453	leaf_free((char*)f);
454	}	454	}
455		455
456	void tTwoZero_initToPool (tTwoZero* const ft, tMempool* const mp)	456	void tTwoZero_initToPool (tTwoZero* const ft, tMempool* const mp)
@@ -468,7 +468,7 @@ void tTwoZero_freeFromPool (tTwoZero* const ft, tMempool* const mp) · 11 unmodified lines
468	_tMempool* m = *mp;	468	_tMempool* m = *mp;
469	_tTwoZero* f = *ft;	469	_tTwoZero* f = *ft;
470		470
471	mpool_free(f, m);	471	mpool_free((char*)f, m);
472	}	472	}
473		473
474	float tTwoZero_tick(tTwoZero* const ft, float input)	474	float tTwoZero_tick(tTwoZero* const ft, float input)
@@ -558,7 +558,7 @@ void tPoleZero_free(tPoleZero* const pzf) · 83 unmodified lines
558	{	558	{
559	_tPoleZero* f = *pzf;	559	_tPoleZero* f = *pzf;
560		560
561	leaf_free(f);	561	leaf_free((char*)f);
562	}	562	}
563		563
564	void tPoleZero_initToPool (tPoleZero* const pzf, tMempool* const mp)	564	void tPoleZero_initToPool (tPoleZero* const pzf, tMempool* const mp)
@@ -579,7 +579,7 @@ void tPoleZero_freeFromPool (tPoleZero* const pzf, tMempool* const mp) · 14 unmodified lines
579	_tMempool* m = *mp;	579	_tMempool* m = *mp;
580	_tPoleZero* f = *pzf;	580	_tPoleZero* f = *pzf;
581		581
582	mpool_free(f, m);	582	mpool_free((char*)f, m);
583	}	583	}
584		584
585	void tPoleZero_setB0(tPoleZero* const pzf, float b0)	585	void tPoleZero_setB0(tPoleZero* const pzf, float b0)
@@ -689,7 +689,7 @@ void tBiQuad_free(tBiQuad* const ft) · 103 unmodified lines
689	{	689	{
690	_tBiQuad* f = *ft;	690	_tBiQuad* f = *ft;
691		691
692	leaf_free(f);	692	leaf_free((char*)f);
693	}	693	}
694		694
695	void tBiQuad_initToPool (tBiQuad* const ft, tMempool* const mp)	695	void tBiQuad_initToPool (tBiQuad* const ft, tMempool* const mp)
@@ -713,7 +713,7 @@ void tBiQuad_freeFromPool (tBiQuad* const ft, tMempool* const mp) · 17 unmodified lines
713	_tMempool* m = *mp;	713	_tMempool* m = *mp;
714	_tBiQuad* f = *ft;	714	_tBiQuad* f = *ft;
715		715
716	mpool_free(f, m);	716	mpool_free((char*)f, m);
717	}	717	}
718		718
719	float tBiQuad_tick(tBiQuad* const ft, float input)	719	float tBiQuad_tick(tBiQuad* const ft, float input)
@@ -923,7 +923,7 @@ void tSVF_freeFromPool (tSVF* const svff, tMempool* const mp) · 203 unmodified lines
923	_tMempool* m = *mp;	923	_tMempool* m = *mp;
924	_tSVF* svf = *svff;	924	_tSVF* svf = *svff;
925		925
926	mpool_free(svf, m);	926	mpool_free((char*)svf, m);
927	}	927	}
928		928
929	float tSVF_tick(tSVF* const svff, float v0)	929	float tSVF_tick(tSVF* const svff, float v0)
@@ -992,7 +992,7 @@ void tEfficientSVF_free(tEfficientSVF* const svff) · 62 unmodified lines
992	{	992	{
993	_tEfficientSVF* svf = *svff;	993	_tEfficientSVF* svf = *svff;
994		994
995	leaf_free(svf);	995	leaf_free((char*)svf);
996	}	996	}
997		997
998	void tEfficientSVF_initToPool (tEfficientSVF* const svff, SVFType type, uint16_t input, float Q, tMempool* const mp)	998	void tEfficientSVF_initToPool (tEfficientSVF* const svff, SVFType type, uint16_t input, float Q, tMempool* const mp)
@@ -1017,7 +1017,7 @@ void tEfficientSVF_freeFromPool (tEfficientSVF* const svff, tMempool* const · 18 unmodified lines
1017	_tMempool* m = *mp;	1017	_tMempool* m = *mp;
1018	_tEfficientSVF* svf = *svff;	1018	_tEfficientSVF* svf = *svff;
1019		1019
1020	mpool_free(svf, m);	1020	mpool_free((char*)svf, m);
1021	}	1021	}
1022		1022
1023	float tEfficientSVF_tick(tEfficientSVF* const svff, float v0)	1023	float tEfficientSVF_tick(tEfficientSVF* const svff, float v0)
@@ -1076,7 +1076,7 @@ void tHighpass_free(tHighpass* const ft) · 52 unmodified lines
1076	{	1076	{
1077	_tHighpass* f = *ft;	1077	_tHighpass* f = *ft;
1078		1078
1079	leaf_free(f);	1079	leaf_free((char*)f);
1080	}	1080	}
1081		1081
1082	void tHighpass_initToPool (tHighpass* const ft, float freq, tMempool* const mp)	1082	void tHighpass_initToPool (tHighpass* const ft, float freq, tMempool* const mp)
@@ -1096,7 +1096,7 @@ void tHighpass_freeFromPool (tHighpass* const ft, tMempool* const mp) · 13 unmodified lines
1096	_tMempool* m = *mp;	1096	_tMempool* m = *mp;
1097	_tHighpass* f = *ft;	1097	_tHighpass* f = *ft;
1098		1098
1099	mpool_free(f, m);	1099	mpool_free((char*)f, m);
1100	}	1100	}
1101		1101
1102	void tHighpass_setFreq(tHighpass* const ft, float freq)	1102	void tHighpass_setFreq(tHighpass* const ft, float freq)
@@ -1157,7 +1157,7 @@ void tButterworth_free(tButterworth* const ft) · 54 unmodified lines
1157	tSVF_free(&f->high[i]);	1157	tSVF_free(&f->high[i]);
1158	}	1158	}
1159		1159
1160	leaf_free(f);	1160	leaf_free((char*)f);
1161	}	1161	}
1162		1162
1163	void tButterworth_initToPool (tButterworth* const ft, int N, float f1, float f2, tMempool* const mp)	1163	void tButterworth_initToPool (tButterworth* const ft, int N, float f1, float f2, tMempool* const mp)
@@ -1191,7 +1191,7 @@ void tButterworth_freeFromPool (tButterworth* const ft, tMempool* const mp) · 27 unmodified lines
1191	tSVF_freeFromPool(&f->high[i], mp);	1191	tSVF_freeFromPool(&f->high[i], mp);
1192	}	1192	}
1193		1193
1194	mpool_free(f, m);	1194	mpool_free((char*)f, m);
1195	}	1195	}
1196		1196
1197	float tButterworth_tick(tButterworth* const ft, float samp)	1197	float tButterworth_tick(tButterworth* const ft, float samp)
@@ -1249,8 +1249,8 @@ void tFIR_free(tFIR* const firf) · 51 unmodified lines
1249	{	1249	{
1250	_tFIR* fir = *firf;	1250	_tFIR* fir = *firf;
1251		1251
1252	leaf_free(fir->past);	1252	leaf_free((char*)fir->past);
1253	leaf_free(fir);	1253	leaf_free((char*)fir);
1254	}	1254	}
1255		1255
1256	void tFIR_initToPool (tFIR* const firf, float* coeffs, int numTaps, tMempool* const mp)	1256	void tFIR_initToPool (tFIR* const firf, float* coeffs, int numTaps, tMempool* const mp)
@@ -1269,8 +1269,8 @@ void tFIR_freeFromPool (tFIR* const firf, tMempool* const mp) · 12 unmodified lines
1269	_tMempool* m = *mp;	1269	_tMempool* m = *mp;
1270	_tFIR* fir = *firf;	1270	_tFIR* fir = *firf;
1271		1271
1272	mpool_free(fir->past, m);	1272	mpool_free((char*)fir->past, m);
1273	mpool_free(fir, m);	1273	mpool_free((char*)fir, m);
1274	}	1274	}
1275		1275
1276	float tFIR_tick(tFIR* const firf, float input)	1276	float tFIR_tick(tFIR* const firf, float input)
@@ -1321,9 +1321,9 @@ void tMedianFilter_freeFromPool (tMedianFilter* const mf, tMempool* const m · 44 unmodified lines
1321	_tMempool* m = *mp;	1321	_tMempool* m = *mp;
1322	_tMedianFilter* f = *mf;	1322	_tMedianFilter* f = *mf;
1323		1323
1324	mpool_free(f->val, m);	1324	mpool_free((char*)f->val, m);
1325	mpool_free(f->age, m);	1325	mpool_free((char*)f->age, m);
1326	mpool_free(f, m);	1326	mpool_free((char*)f, m);
1327	}	1327	}
1328		1328
1329	float tMedianFilter_tick (tMedianFilter* const mf, float input)	1329	float tMedianFilter_tick (tMedianFilter* const mf, float input)
@@ -1399,7 +1399,7 @@ void tVZFilter_freeFromPool (tVZFilter* const vf, tMempool* const mp) · 69 unmodified lines
1399	{	1399	{
1400	_tMempool* m = *mp;	1400	_tMempool* m = *mp;
1401	_tVZFilter* f = vf = (_tVZFilter) mpool_alloc(sizeof(_tVZFilter), m);	1401	_tVZFilter* f = vf = (_tVZFilter) mpool_alloc(sizeof(_tVZFilter), m);
1402	mpool_free(f, m);	1402	mpool_free((char*)f, m);
1403	}	1403	}
1404		1404
1405	void tVZFilter_setSampleRate (tVZFilter* const vf, float sampleRate)	1405	void tVZFilter_setSampleRate (tVZFilter* const vf, float sampleRate)
@@ -1699,7 +1699,7 @@ void tDiodeFilter_freeFromPool (tDiodeFilter* const vf, tMempool* const mp) · 293 unmodified lines
1699	{	1699	{
1700	_tMempool* m = *mp;	1700	_tMempool* m = *mp;
1701	_tDiodeFilter* f = vf = (_tDiodeFilter) mpool_alloc(sizeof(_tDiodeFilter), m);	1701	_tDiodeFilter* f = vf = (_tDiodeFilter) mpool_alloc(sizeof(_tDiodeFilter), m);
1702	mpool_free(f, m);	1702	mpool_free((char*)f, m);
1703	}	1703	}
1704		1704
1705	float tanhXdX(float x)	1705	float tanhXdX(float x)

LEAF/Src/leaf-instruments.c+8−8

@@ -60,7 +60,7 @@ void t808Cowebell_free(t808Cowbell* const cowbellInst) · 59 unmodified lines
60	tHighpass_free(&cowbell->highpass);	60	tHighpass_free(&cowbell->highpass);
61	tNoise_free(&cowbell->stick);	61	tNoise_free(&cowbell->stick);
62	tEnvelope_free(&cowbell->envStick);	62	tEnvelope_free(&cowbell->envStick);
63	leaf_free(cowbell);	63	leaf_free((char*)cowbell);
64	}	64	}
65		65
66	void t808Cowbell_initToPool (t808Cowbell* const cowbellInst, int useStick, tMempool* const mp)	66	void t808Cowbell_initToPool (t808Cowbell* const cowbellInst, int useStick, tMempool* const mp)
@@ -107,7 +107,7 @@ void t808Cowbell_freeFromPool (t808Cowbell* const cowbellInst, tMempoo · 40 unmodified lines
107	tHighpass_freeFromPool(&cowbell->highpass, mp);	107	tHighpass_freeFromPool(&cowbell->highpass, mp);
108	tNoise_freeFromPool(&cowbell->stick, mp);	108	tNoise_freeFromPool(&cowbell->stick, mp);
109	tEnvelope_freeFromPool(&cowbell->envStick, mp);	109	tEnvelope_freeFromPool(&cowbell->envStick, mp);
110	mpool_free(cowbell, m);	110	mpool_free((char*)cowbell, m);
111	}	111	}
112		112
113	void t808Cowbell_on(t808Cowbell* const cowbellInst, float vel)	113	void t808Cowbell_on(t808Cowbell* const cowbellInst, float vel)
@@ -236,7 +236,7 @@ void t808Hihat_free(t808Hihat* const hihatInst) · 122 unmodified lines
236		236
237	tHighpass_free(&hihat->highpass);	237	tHighpass_free(&hihat->highpass);
238		238
239	leaf_free(hihat);	239	leaf_free((char*)hihat);
240	}	240	}
241		241
242	void t808Hihat_initToPool (t808Hihat* const hihatInst, tMempool* const mp)	242	void t808Hihat_initToPool (t808Hihat* const hihatInst, tMempool* const mp)
@@ -294,7 +294,7 @@ void t808Hihat_freeFromPool (t808Hihat* const hihatInst, tMempool* const mp) · 51 unmodified lines
294		294
295	tHighpass_freeFromPool(&hihat->highpass, mp);	295	tHighpass_freeFromPool(&hihat->highpass, mp);
296		296
297	mpool_free(hihat, m);	297	mpool_free((char*)hihat, m);
298	}	298	}
299		299
300	void t808Hihat_on(t808Hihat* const hihatInst, float vel)	300	void t808Hihat_on(t808Hihat* const hihatInst, float vel)
@@ -448,7 +448,7 @@ void t808Snare_free (t808Snare* const snareInst) · 147 unmodified lines
448	tEnvelope_free(&snare->noiseEnvGain);	448	tEnvelope_free(&snare->noiseEnvGain);
449	tEnvelope_free(&snare->noiseEnvFilter);	449	tEnvelope_free(&snare->noiseEnvFilter);
450		450
451	leaf_free(snare);	451	leaf_free((char*)snare);
452	}	452	}
453		453
454	void t808Snare_initToPool (t808Snare* const snareInst, tMempool* const mp)	454	void t808Snare_initToPool (t808Snare* const snareInst, tMempool* const mp)
@@ -499,7 +499,7 @@ void t808Snare_freeFromPool (t808Snare* const snareInst, tMempool* const mp) · 44 unmodified lines
499	tEnvelope_freeFromPool(&snare->noiseEnvGain, mp);	499	tEnvelope_freeFromPool(&snare->noiseEnvGain, mp);
500	tEnvelope_freeFromPool(&snare->noiseEnvFilter, mp);	500	tEnvelope_freeFromPool(&snare->noiseEnvFilter, mp);
501		501
502	mpool_free(snare, m);	502	mpool_free((char*)snare, m);
503	}	503	}
504		504
505	void t808Snare_on(t808Snare* const snareInst, float vel)	505	void t808Snare_on(t808Snare* const snareInst, float vel)
@@ -623,7 +623,7 @@ void t808Kick_free (t808Kick* const kickInst) · 117 unmodified lines
623	tNoise_free(&kick->noiseOsc);	623	tNoise_free(&kick->noiseOsc);
624	tEnvelope_free(&kick->noiseEnvGain);	624	tEnvelope_free(&kick->noiseEnvGain);
625		625
626	leaf_free(kick);	626	leaf_free((char*)kick);
627	}	627	}
628		628
629	void t808Kick_initToPool (t808Kick* const kickInst, tMempool* const mp)	629	void t808Kick_initToPool (t808Kick* const kickInst, tMempool* const mp)
@@ -658,7 +658,7 @@ void t808Kick_freeFromPool (t808Kick* const kickInst, tMempool* const mp) · 28 unmodified lines
658	tNoise_freeFromPool(&kick->noiseOsc, mp);	658	tNoise_freeFromPool(&kick->noiseOsc, mp);
659	tEnvelope_freeFromPool(&kick->noiseEnvGain, mp);	659	tEnvelope_freeFromPool(&kick->noiseEnvGain, mp);
660		660
661	mpool_free(kick, m);	661	mpool_free((char*)kick, m);
662	}	662	}
663		663
664	float t808Kick_tick (t808Kick* const kickInst)	664	float t808Kick_tick (t808Kick* const kickInst)

LEAF/Src/leaf-math.c+2−2

@@ -126,8 +126,8 @@ float fastexp2f(float x) · 125 unmodified lines
126	{	126	{
127	if (x >= -127.0)	127	if (x >= -127.0)
128	{	128	{
129	register float accumulator, xPower;	129	float accumulator, xPower;
130	register union {float f; int32_t i;} xBits;	130	union {float f; int32_t i;} xBits;
131		131
132	xBits.i = (int32_t)(x + 4096.0f) - 4096L; /* integer part */	132	xBits.i = (int32_t)(x + 4096.0f) - 4096L; /* integer part */
133	x -= (float)(xBits.i); /* fractional part */	133	x -= (float)(xBits.i); /* fractional part */

LEAF/Src/leaf-mempool.c+14−14

@@ -52,7 +52,7 @@ · 51 unmodified lines
52	* private function	52	* private function
53	*/	53	*/
54	static inline size_t mpool_align(size_t size);	54	static inline size_t mpool_align(size_t size);
55	static inline mpool_node_t* create_node(void* block_location, mpool_node_t* next, mpool_node_t* prev, size_t size);	55	static inline mpool_node_t* create_node(char* block_location, mpool_node_t* next, mpool_node_t* prev, size_t size);
56	static inline void delink_node(mpool_node_t* node);	56	static inline void delink_node(mpool_node_t* node);
57		57
58	/**	58	/**
@@ -62,7 +62,7 @@ void mpool_create (char* memory, size_t size, _tMempool* pool) · 3 unmodified lines
62	{	62	{
63	leaf.header_size = mpool_align(sizeof(mpool_node_t));	63	leaf.header_size = mpool_align(sizeof(mpool_node_t));
64		64
65	pool->mpool = (void*)memory;	65	pool->mpool = (char*)memory;
66	pool->usize = 0;	66	pool->usize = 0;
67	pool->msize = size;	67	pool->msize = size;
68		68
@@ -87,7 +87,7 @@ void leaf_pool_init(char* memory, size_t size) · 18 unmodified lines
87	/**	87	/**
88	* allocate memory from memory pool	88	* allocate memory from memory pool
89	*/	89	*/
90	void* mpool_alloc(size_t asize, _tMempool* pool)	90	char* mpool_alloc(size_t asize, _tMempool* pool)
91	{	91	{
92	// If the head is NULL, the mempool is full	92	// If the head is NULL, the mempool is full
93	if (pool->head == NULL)	93	if (pool->head == NULL)
@@ -161,7 +161,7 @@ void* mpool_alloc(size_t asize, _tMempool* pool) · 67 unmodified lines
161	/**	161	/**
162	* allocate memory from memory pool and also clear that memory to be blank	162	* allocate memory from memory pool and also clear that memory to be blank
163	*/	163	*/
164	void* mpool_calloc(size_t asize, _tMempool* pool)	164	char* mpool_calloc(size_t asize, _tMempool* pool)
165	{	165	{
166	// If the head is NULL, the mempool is full	166	// If the head is NULL, the mempool is full
167	if (pool->head == NULL)	167	if (pool->head == NULL)
@@ -227,20 +227,20 @@ void* mpool_calloc(size_t asize, _tMempool* pool) · 59 unmodified lines
227	return node_to_alloc->pool;	227	return node_to_alloc->pool;
228	}	228	}
229		229
230	void* leaf_alloc(size_t size)	230	char* leaf_alloc(size_t size)
231	{	231	{
232	//printf("alloc %i\n", size);	232	//printf("alloc %i\n", size);
233	void* block = mpool_alloc(size, &leaf._mempool);	233	char* block = mpool_alloc(size, &leaf._mempool);
234		234
235	if (block == NULL) leaf_mempool_overrun();	235	if (block == NULL) leaf_mempool_overrun();
236		236
237	return block;	237	return block;
238	}	238	}
239		239
240	void* leaf_calloc(size_t size)	240	char* leaf_calloc(size_t size)
241	{	241	{
242	//printf("alloc %i\n", size);	242	//printf("alloc %i\n", size);
243	void* block = mpool_calloc(size, &leaf._mempool);	243	char* block = mpool_calloc(size, &leaf._mempool);
244		244
245	if (block == NULL) leaf_mempool_overrun();	245	if (block == NULL) leaf_mempool_overrun();
246		246
@@ -248,7 +248,7 @@ void* leaf_calloc(size_t size) · 1 unmodified line
248	return block;	248	return block;
249	}	249	}
250		250
251	void mpool_free(void* ptr, _tMempool* pool)	251	void mpool_free(char* ptr, _tMempool* pool)
252	{	252	{
253	//if (ptr < pool->mpool \|\| ptr >= pool->mpool + pool->msize)	253	//if (ptr < pool->mpool \|\| ptr >= pool->mpool + pool->msize)
254	// Get the node at the freed space	254	// Get the node at the freed space
@@ -310,7 +310,7 @@ void mpool_free(void* ptr, _tMempool* pool) · 55 unmodified lines
310	// for (int i = 0; i < freed_node->size; i++) freed_pool[i] = 0;	310	// for (int i = 0; i < freed_node->size; i++) freed_pool[i] = 0;
311	}	311	}
312		312
313	void leaf_free(void* ptr)	313	void leaf_free(char* ptr)
314	{	314	{
315	mpool_free(ptr, &leaf._mempool);	315	mpool_free(ptr, &leaf._mempool);
316	}	316	}
@@ -335,9 +335,9 @@ size_t leaf_pool_get_used(void) · 18 unmodified lines
335	return mpool_get_used(&leaf._mempool);	335	return mpool_get_used(&leaf._mempool);
336	}	336	}
337		337
338	void* leaf_pool_get_pool(void)	338	char* leaf_pool_get_pool(void)
339	{	339	{
340	float* buff = (float*)leaf._mempool.mpool;	340	char* buff = leaf._mempool.mpool;
341		341
342	return buff;	342	return buff;
343	}	343	}
@@ -349,7 +349,7 @@ static inline size_t mpool_align(size_t size) { · 5 unmodified lines
349	return (size + (MPOOL_ALIGN_SIZE - 1)) & ~(MPOOL_ALIGN_SIZE - 1);	349	return (size + (MPOOL_ALIGN_SIZE - 1)) & ~(MPOOL_ALIGN_SIZE - 1);
350	}	350	}
351		351
352	static inline mpool_node_t* create_node(void* block_location, mpool_node_t* next, mpool_node_t* prev, size_t size)	352	static inline mpool_node_t* create_node(char* block_location, mpool_node_t* next, mpool_node_t* prev, size_t size)
353	{	353	{
354	mpool_node_t* node = (mpool_node_t*)block_location;	354	mpool_node_t* node = (mpool_node_t*)block_location;
355	node->pool = block_location + leaf.header_size;	355	node->pool = block_location + leaf.header_size;
@@ -408,5 +408,5 @@ void tMempool_freeFromPool (tMempool* const mp, tMempool* const mem) · 52 unmodified lines
408	_tMempool* mm = *mem;	408	_tMempool* mm = *mem;
409	_tMempool* m = *mp;	409	_tMempool* m = *mp;
410		410
411	mpool_free(m, mm);	411	mpool_free((char*)m, mm);
412	}	412	}

LEAF/Src/leaf-midi.c+17−17

@@ -36,7 +36,7 @@ void tStack_free(tStack* const stack) · 35 unmodified lines
36	{	36	{
37	_tStack* ns = *stack;	37	_tStack* ns = *stack;
38		38
39	leaf_free(ns);	39	leaf_free((char*)ns);
40	}	40	}
41		41
42	void tStack_initToPool (tStack* const stack, tMempool* const mp)	42	void tStack_initToPool (tStack* const stack, tMempool* const mp)
@@ -57,7 +57,7 @@ void tStack_freeFromPool (tStack* const stack, tMempool* const mp) · 14 unmodified lines
57	_tMempool* m = *mp;	57	_tMempool* m = *mp;
58	_tStack* ns = *stack;	58	_tStack* ns = *stack;
59		59
60	mpool_free(ns, m);	60	mpool_free((char*)ns, m);
61	}	61	}
62		62
63	// If stack contains note, returns index. Else returns -1;	63	// If stack contains note, returns index. Else returns -1;
@@ -322,18 +322,18 @@ void tPoly_free(tPoly* const polyh) · 258 unmodified lines
322	for (int i = 0; i < poly->maxNumVoices; i++)	322	for (int i = 0; i < poly->maxNumVoices; i++)
323	{	323	{
324	tRamp_free(&poly->ramps[i]);	324	tRamp_free(&poly->ramps[i]);
325	leaf_free(poly->voices[i]);	325	leaf_free((char*)poly->voices[i]);
326	}	326	}
327	tRamp_free(&poly->pitchBendRamp);	327	tRamp_free(&poly->pitchBendRamp);
328	tStack_free(&poly->stack);	328	tStack_free(&poly->stack);
329	tStack_free(&poly->orderStack);	329	tStack_free(&poly->orderStack);
330		330
331	leaf_free(poly->voices);	331	leaf_free((char*)poly->voices);
332	leaf_free(poly->ramps);	332	leaf_free((char*)poly->ramps);
333	leaf_free(poly->rampVals);	333	leaf_free((char*)poly->rampVals);
334	leaf_free(poly->firstReceived);	334	leaf_free((char*)poly->firstReceived);
335		335
336	leaf_free(poly);	336	leaf_free((char*)poly);
337	}	337	}
338		338
339	void tPoly_initToPool (tPoly* const polyh, int maxNumVoices, tMempool* const mp)	339	void tPoly_initToPool (tPoly* const polyh, int maxNumVoices, tMempool* const mp)
@@ -390,18 +390,18 @@ void tPoly_freeFromPool (tPoly* const polyh, tMempool* const mp) · 50 unmodified lines
390	for (int i = 0; i < poly->maxNumVoices; i++)	390	for (int i = 0; i < poly->maxNumVoices; i++)
391	{	391	{
392	tRamp_freeFromPool(&poly->ramps[i], mp);	392	tRamp_freeFromPool(&poly->ramps[i], mp);
393	mpool_free(poly->voices[i], m);	393	mpool_free((char*)poly->voices[i], m);
394	}	394	}
395	tRamp_freeFromPool(&poly->pitchBendRamp, mp);	395	tRamp_freeFromPool(&poly->pitchBendRamp, mp);
396	tStack_freeFromPool(&poly->stack, mp);	396	tStack_freeFromPool(&poly->stack, mp);
397	tStack_freeFromPool(&poly->orderStack, mp);	397	tStack_freeFromPool(&poly->orderStack, mp);
398		398
399	mpool_free(poly->voices, m);	399	mpool_free((char*)poly->voices, m);
400	mpool_free(poly->ramps, m);	400	mpool_free((char*)poly->ramps, m);
401	mpool_free(poly->rampVals, m);	401	mpool_free((char*)poly->rampVals, m);
402	mpool_free(poly->firstReceived, m);	402	mpool_free((char*)poly->firstReceived, m);
403		403
404	mpool_free(poly, m);	404	mpool_free((char*)poly, m);
405	}	405	}
406		406
407	void tPoly_tickPitch(tPoly* polyh)	407	void tPoly_tickPitch(tPoly* polyh)
@@ -730,11 +730,11 @@ void tSimplePoly_freeFromPool (tSimplePoly* const polyh, tMempool* const mp) · 322 unmodified lines
730		730
731	for (int i = 0; i < poly->maxNumVoices; i++)	731	for (int i = 0; i < poly->maxNumVoices; i++)
732	{	732	{
733	mpool_free(poly->voices[i], m);	733	mpool_free((char*)poly->voices[i], m);
734	}	734	}
735	tStack_freeFromPool(&poly->stack, mp);	735	tStack_freeFromPool(&poly->stack, mp);
736	mpool_free(poly->voices, m);	736	mpool_free((char*)poly->voices, m);
737	mpool_free(poly, m);	737	mpool_free((char*)poly, m);
738	}	738	}
739		739
740	int tSimplePoly_noteOn(tSimplePoly* const polyh, int note, uint8_t vel)	740	int tSimplePoly_noteOn(tSimplePoly* const polyh, int note, uint8_t vel)

LEAF/Src/leaf-oscillators.c+21−21

@@ -42,7 +42,7 @@ void tCycle_freeFromPool (tCycle* const cy, tMempool* const mp) · 41 unmodified lines
42	_tMempool* m = *mp;	42	_tMempool* m = *mp;
43	_tCycle* c = *cy;	43	_tCycle* c = *cy;
44		44
45	mpool_free(c, m);	45	mpool_free((char*)c, m);
46	}	46	}
47		47
48	void tCycle_setFreq(tCycle* const cy, float freq)	48	void tCycle_setFreq(tCycle* const cy, float freq)
@@ -116,7 +116,7 @@ void tTriangle_freeFromPool (tTriangle* const cy, tMempool* const mp) · 67 unmodified lines
116	_tMempool* m = *mp;	116	_tMempool* m = *mp;
117	_tTriangle* c = *cy;	117	_tTriangle* c = *cy;
118		118
119	mpool_free(c, m);	119	mpool_free((char*)c, m);
120	}	120	}
121		121
122	void tTriangle_setFreq(tTriangle* const cy, float freq)	122	void tTriangle_setFreq(tTriangle* const cy, float freq)
@@ -190,7 +190,7 @@ void tSquare_freeFromPool(tSquare* const cy, tMempool* const mp) · 67 unmodified lines
190	_tMempool* m = *mp;	190	_tMempool* m = *mp;
191	_tSquare* c = *cy;	191	_tSquare* c = *cy;
192		192
193	mpool_free(c, m);	193	mpool_free((char*)c, m);
194	}	194	}
195		195
196	void tSquare_setFreq(tSquare* const cy, float freq)	196	void tSquare_setFreq(tSquare* const cy, float freq)
@@ -263,7 +263,7 @@ void tSawtooth_freeFromPool (tSawtooth* const cy, tMempool* const mp) · 66 unmodified lines
263	_tMempool* m = *mp;	263	_tMempool* m = *mp;
264	_tSawtooth* c = *cy;	264	_tSawtooth* c = *cy;
265		265
266	mpool_free(c, m);	266	mpool_free((char*)c, m);
267	}	267	}
268		268
269	void tSawtooth_setFreq(tSawtooth* const cy, float freq)	269	void tSawtooth_setFreq(tSawtooth* const cy, float freq)
@@ -338,8 +338,8 @@ void tSine_freeFromPool (tSine* const cy, tMempool* const mp) · 68 unmodified lines
338	_tMempool* m = *mp;	338	_tMempool* m = *mp;
339	_tSine* c = *cy;	339	_tSine* c = *cy;
340		340
341	mpool_free(c->sine, m);	341	mpool_free((char*)c->sine, m);
342	mpool_free(c, m);	342	mpool_free((char*)c, m);
343	}	343	}
344		344
345	void tSine_setFreq(tSine* const cy, float freq)	345	void tSine_setFreq(tSine* const cy, float freq)
@@ -413,7 +413,7 @@ void tTri_freeFromPool (tTri* const cy, tMempool* const mp) · 67 unmodified lines
413	_tMempool* m = *mp;	413	_tMempool* m = *mp;
414	_tTri* c = *cy;	414	_tTri* c = *cy;
415		415
416	mpool_free(c, m);	416	mpool_free((char*)c, m);
417	}	417	}
418		418
419	float tTri_tick (tTri* const osc)	419	float tTri_tick (tTri* const osc)
@@ -492,7 +492,7 @@ void tPulse_freeFromPool(tPulse* const osc, tMempool* const mp) · 72 unmodified lines
492	_tMempool* m = *mp;	492	_tMempool* m = *mp;
493	_tPulse* c = *osc;	493	_tPulse* c = *osc;
494		494
495	mpool_free(c, m);	495	mpool_free((char*)c, m);
496	}	496	}
497		497
498	float tPulse_tick (tPulse* const osc)	498	float tPulse_tick (tPulse* const osc)
@@ -556,7 +556,7 @@ void tSaw_freeFromPool (tSaw* const osc, tMempool* const mp) · 57 unmodified lines
556	_tMempool* m = *mp;	556	_tMempool* m = *mp;
557	_tSaw* c = *osc;	557	_tSaw* c = *osc;
558		558
559	mpool_free(c, m);	559	mpool_free((char*)c, m);
560	}	560	}
561		561
562	float tSaw_tick (tSaw* const osc)	562	float tSaw_tick (tSaw* const osc)
@@ -618,7 +618,7 @@ void tPhasor_freeFromPool(tPhasor* const ph, tMempool* const mp) · 55 unmodified lines
618	_tMempool* m = *mp;	618	_tMempool* m = *mp;
619	_tPhasor* p = *ph;	619	_tPhasor* p = *ph;
620		620
621	mpool_free(p, m);	621	mpool_free((char*)p, m);
622	}	622	}
623		623
624	void tPhasor_setFreq(tPhasor* const ph, float freq)	624	void tPhasor_setFreq(tPhasor* const ph, float freq)
@@ -672,7 +672,7 @@ void tNoise_freeFromPool (tNoise* const ns, tMempool* const mp) · 47 unmodified lines
672	_tMempool* m = *mp;	672	_tMempool* m = *mp;
673	_tNoise* n = *ns;	673	_tNoise* n = *ns;
674		674
675	mpool_free(n, m);	675	mpool_free((char*)n, m);
676	}	676	}
677		677
678	float tNoise_tick(tNoise* const ns)	678	float tNoise_tick(tNoise* const ns)
@@ -752,7 +752,7 @@ void tNeuron_freeFromPool(tNeuron* const nr, tMempool* const mp) · 73 unmodified lines
752	_tNeuron* n = *nr;	752	_tNeuron* n = *nr;
753		753
754	tPoleZero_free(&n->f);	754	tPoleZero_free(&n->f);
755	mpool_free(n, m);	755	mpool_free((char*)n, m);
756	}	756	}
757		757
758	void tNeuron_reset(tNeuron* const nr)	758	void tNeuron_reset(tNeuron* const nr)
@@ -981,15 +981,15 @@ void tMinBLEP_freeFromPool (tMinBLEP* const minblep, tMempool* const mp) · 222 unmodified lines
981	_tMempool* m = *mp;	981	_tMempool* m = *mp;
982	_tMinBLEP* mb = *minblep;	982	_tMinBLEP* mb = *minblep;
983		983
984	mpool_free(mb->offset, m);	984	mpool_free((char*)mb->offset, m);
985	// mpool_free(mb->freqMultiple, m);	985	// mpool_free(mb->freqMultiple, m);
986	mpool_free(mb->pos_change_magnitude, m);	986	mpool_free((char*)mb->pos_change_magnitude, m);
987	mpool_free(mb->vel_change_magnitude, m);	987	mpool_free((char*)mb->vel_change_magnitude, m);
988		988
989	mpool_free(mb->minBlepArray, m);	989	mpool_free((char*)mb->minBlepArray, m);
990	mpool_free(mb->minBlepDerivArray, m);	990	mpool_free((char*)mb->minBlepDerivArray, m);
991		991
992	mpool_free(mb, m);	992	mpool_free((char*)mb, m);
993	}	993	}
994		994
995	// SINC Function	995	// SINC Function
@@ -1382,7 +1382,7 @@ void tMBTriangle_freeFromPool (tMBTriangle* const cy, tMempool* const mp) · 386 unmodified lines
1382	tMinBLEP_freeFromPool(&c->minBlep, mp);	1382	tMinBLEP_freeFromPool(&c->minBlep, mp);
1383	tHighpass_freeFromPool(&c->dcBlock, mp);	1383	tHighpass_freeFromPool(&c->dcBlock, mp);
1384		1384
1385	mpool_free(c, m);	1385	mpool_free((char*)c, m);
1386	}	1386	}
1387		1387
1388	float tMBTriangle_tick (tMBTriangle* const osc)	1388	float tMBTriangle_tick (tMBTriangle* const osc)
@@ -1521,7 +1521,7 @@ void tMBPulse_freeFromPool(tMBPulse* const osc, tMempool* const mp) · 132 unmodified lines
1521	tMinBLEP_freeFromPool(&c->minBlep, mp);	1521	tMinBLEP_freeFromPool(&c->minBlep, mp);
1522	tHighpass_freeFromPool(&c->dcBlock, mp);	1522	tHighpass_freeFromPool(&c->dcBlock, mp);
1523		1523
1524	mpool_free(c, m);	1524	mpool_free((char*)c, m);
1525	}	1525	}
1526		1526
1527	float tMBPulse_tick (tMBPulse* const osc)	1527	float tMBPulse_tick (tMBPulse* const osc)
@@ -1618,7 +1618,7 @@ void tMBSaw_freeFromPool (tMBSaw* const osc, tMempool* const mp) · 90 unmodified lines
1618	tMinBLEP_freeFromPool(&c->minBlep, mp);	1618	tMinBLEP_freeFromPool(&c->minBlep, mp);
1619	tHighpass_freeFromPool(&c->dcBlock, mp);	1619	tHighpass_freeFromPool(&c->dcBlock, mp);
1620		1620
1621	mpool_free(c, m);	1621	mpool_free((char*)c, m);
1622	}	1622	}
1623		1623
1624	float tMBSaw_tick (tMBSaw* const osc)	1624	float tMBSaw_tick (tMBSaw* const osc)

LEAF/Src/leaf-physical.c+6−6

@@ -56,7 +56,7 @@ void tPluck_freeFromPool (tPluck* const pl, tMempool* const mp) · 55 unmodified lines
56	tOneZero_freeFromPool(&p->loopFilter, mp);	56	tOneZero_freeFromPool(&p->loopFilter, mp);
57	tAllpassDelay_freeFromPool(&p->delayLine, mp);	57	tAllpassDelay_freeFromPool(&p->delayLine, mp);
58		58
59	mpool_free(p, m);	59	mpool_free((char*)p, m);
60	}	60	}
61		61
62	float tPluck_getLastOut (tPluck* const pl)	62	float tPluck_getLastOut (tPluck* const pl)
@@ -194,7 +194,7 @@ void tKarplusStrong_freeFromPool (tKarplusStrong* const pl, tMempool* const m · 131 unmodified lines
194	tBiQuad_freeFromPool(&p->biquad[i], mp);	194	tBiQuad_freeFromPool(&p->biquad[i], mp);
195	}	195	}
196		196
197	mpool_free(p, m);	197	mpool_free((char*)p, m);
198	}	198	}
199		199
200	float tKarplusStrong_getLastOut (tKarplusStrong* const pl)	200	float tKarplusStrong_getLastOut (tKarplusStrong* const pl)
@@ -396,7 +396,7 @@ void tSimpleLivingString_freeFromPool (tSimpleLivingString* const pl, tMem · 195 unmodified lines
396	tHighpass_freeFromPool(&p->DCblocker, mp);	396	tHighpass_freeFromPool(&p->DCblocker, mp);
397	tFeedbackLeveler_freeFromPool(&p->fbLev, mp);	397	tFeedbackLeveler_freeFromPool(&p->fbLev, mp);
398		398
399	mpool_free(p, m);	399	mpool_free((char*)p, m);
400	}	400	}
401		401
402	void tSimpleLivingString_setFreq(tSimpleLivingString* const pl, float freq)	402	void tSimpleLivingString_setFreq(tSimpleLivingString* const pl, float freq)
@@ -544,7 +544,7 @@ void tLivingString_freeFromPool (tLivingString* const pl, tMempool* const mp · 141 unmodified lines
544	tFeedbackLeveler_freeFromPool(&p->fbLevU, mp);	544	tFeedbackLeveler_freeFromPool(&p->fbLevU, mp);
545	tFeedbackLeveler_freeFromPool(&p->fbLevL, mp);	545	tFeedbackLeveler_freeFromPool(&p->fbLevL, mp);
546		546
547	mpool_free(p, m);	547	mpool_free((char*)p, m);
548	}	548	}
549		549
550	void tLivingString_setFreq(tLivingString* const pl, float freq)	550	void tLivingString_setFreq(tLivingString* const pl, float freq)
@@ -683,7 +683,7 @@ void tReedTable_free (tReedTable* const pm) · 132 unmodified lines
683	{	683	{
684	_tReedTable* p = *pm;	684	_tReedTable* p = *pm;
685		685
686	leaf_free(p);	686	leaf_free((char*)p);
687	}	687	}
688		688
689	void tReedTable_initToPool (tReedTable* const pm, float offset, float slope, tMempool* const mp)	689	void tReedTable_initToPool (tReedTable* const pm, float offset, float slope, tMempool* const mp)
@@ -700,7 +700,7 @@ void tReedTable_freeFromPool (tReedTable* const pm, tMempool* const mp) · 10 unmodified lines
700	_tMempool* m = *mp;	700	_tMempool* m = *mp;
701	_tReedTable* p = *pm;	701	_tReedTable* p = *pm;
702		702
703	mpool_free(p, m);	703	mpool_free((char*)p, m);
704	}	704	}
705		705
706	float tReedTable_tick (tReedTable* const pm, float input)	706	float tReedTable_tick (tReedTable* const pm, float input)

LEAF/Src/leaf-reverb.c+5−5

@@ -62,7 +62,7 @@ void tPRCReverb_free(tPRCReverb* const rev) · 61 unmodified lines
62	tDelay_free(&r->allpassDelays[0]);	62	tDelay_free(&r->allpassDelays[0]);
63	tDelay_free(&r->allpassDelays[1]);	63	tDelay_free(&r->allpassDelays[1]);
64	tDelay_free(&r->combDelay);	64	tDelay_free(&r->combDelay);
65	leaf_free(r);	65	leaf_free((char*)r);
66	}	66	}
67		67
68	void tPRCReverb_initToPool (tPRCReverb* const rev, float t60, tMempool* const mp)	68	void tPRCReverb_initToPool (tPRCReverb* const rev, float t60, tMempool* const mp)
@@ -110,7 +110,7 @@ void tPRCReverb_freeFromPool (tPRCReverb* const rev, tMempool* const mp) · 41 unmodified lines
110	tDelay_freeFromPool(&r->allpassDelays[0], mp);	110	tDelay_freeFromPool(&r->allpassDelays[0], mp);
111	tDelay_freeFromPool(&r->allpassDelays[1], mp);	111	tDelay_freeFromPool(&r->allpassDelays[1], mp);
112	tDelay_freeFromPool(&r->combDelay, mp);	112	tDelay_freeFromPool(&r->combDelay, mp);
113	mpool_free(r, m);	113	mpool_free((char*)r, m);
114	}	114	}
115		115
116	void tPRCRevert_clear(tPRCReverb* const rev)	116	void tPRCRevert_clear(tPRCReverb* const rev)
@@ -237,7 +237,7 @@ void tNReverb_free(tNReverb* const rev) · 120 unmodified lines
237	tLinearDelay_free(&r->allpassDelays[i]);	237	tLinearDelay_free(&r->allpassDelays[i]);
238	}	238	}
239		239
240	leaf_free(r);	240	leaf_free((char*)r);
241	}	241	}
242		242
243	void tNReverb_initToPool (tNReverb* const rev, float t60, tMempool* const mp)	243	void tNReverb_initToPool (tNReverb* const rev, float t60, tMempool* const mp)
@@ -296,7 +296,7 @@ void tNReverb_freeFromPool (tNReverb* const rev, tMempool* const mp) · 52 unmodified lines
296	tLinearDelay_freeFromPool(&r->allpassDelays[i], mp);	296	tLinearDelay_freeFromPool(&r->allpassDelays[i], mp);
297	}	297	}
298		298
299	mpool_free(r, m);	299	mpool_free((char*)r, m);
300	}	300	}
301		301
302	void tNReverb_setT60(tNReverb* const rev, float t60)	302	void tNReverb_setT60(tNReverb* const rev, float t60)
@@ -567,7 +567,7 @@ void tDattorroReverb_freeFromPool (tDattorroReverb* const rev, tMempool* · 264 unmodified lines
567		567
568	tCycle_freeFromPool(&r->f2_lfo, mp);	568	tCycle_freeFromPool(&r->f2_lfo, mp);
569		569
570	mpool_free(r, m);	570	mpool_free((char*)r, m);
571	}	571	}
572		572
573	void tDattorroReverb_clear (tDattorroReverb* const rev)	573	void tDattorroReverb_clear (tDattorroReverb* const rev)

LEAF/Src/leaf-sampling.c+4−4

@@ -53,8 +53,8 @@ void tBuffer_freeFromPool (tBuffer* const sb, tMempool* const mp) · 52 unmodified lines
53	_tMempool* m = *mp;	53	_tMempool* m = *mp;
54	_tBuffer* s = *sb;	54	_tBuffer* s = *sb;
55		55
56	mpool_free(s->buff, m);	56	mpool_free((char*)s->buff, m);
57	mpool_free(s, m);	57	mpool_free((char*)s, m);
58	}	58	}
59		59
60	void tBuffer_tick (tBuffer* const sb, float sample)	60	void tBuffer_tick (tBuffer* const sb, float sample)
@@ -206,7 +206,7 @@ void tSampler_freeFromPool (tSampler* const sp, tMempool* const mp) · 145 unmodified lines
206	_tSampler* p = *sp;	206	_tSampler* p = *sp;
207	tRamp_freeFromPool(&p->gain, mp);	207	tRamp_freeFromPool(&p->gain, mp);
208		208
209	mpool_free(p, m);	209	mpool_free((char*)p, m);
210	}	210	}
211		211
212	void tSampler_setSample (tSampler* const sp, tBuffer* const b)	212	void tSampler_setSample (tSampler* const sp, tBuffer* const b)
@@ -768,7 +768,7 @@ void tAutoSampler_freeFromPool (tAutoSampler* const as, tMempool* const · 555 unmodified lines
768	tEnvelopeFollower_freeFromPool(&a->ef, mp);	768	tEnvelopeFollower_freeFromPool(&a->ef, mp);
769	tSampler_freeFromPool(&a->sampler, mp);	769	tSampler_freeFromPool(&a->sampler, mp);
770		770
771	mpool_free(a, m);	771	mpool_free((char*)a, m);
772	}	772	}
773		773
774	float tAutoSampler_tick (tAutoSampler* const as, float input)	774	float tAutoSampler_tick (tAutoSampler* const as, float input)

LEAF/leaf.cpp+45−0

@@ -0,0 +1,45 @@
	1	#if _WIN32 \|\| _WIN64
	2
	3	#include ".\leaf.h"
	4	#include ".\Src\leaf-math.c"
	5	#include ".\Src\leaf-mempool.c"
	6	#include ".\Src\leaf-tables.c"
	7	#include ".\Src\leaf-distortion.c"
	8	#include ".\Src\leaf-oscillators.c"
	9	#include ".\Src\leaf-filters.c"
	10	#include ".\Src\leaf-delay.c"
	11	#include ".\Src\leaf-reverb.c"
	12	#include ".\Src\leaf-effects.c"
	13	#include ".\Src\leaf-envelopes.c"
	14	#include ".\Src\leaf-dynamics.c"
	15	#include ".\Src\leaf-analysis.c"
	16	#include ".\Src\leaf-instruments.c"
	17	#include ".\Src\leaf-midi.c"
	18	#include ".\Src\leaf-sampling.c"
	19	#include ".\Src\leaf-physical.c"
	20	#include ".\Src\leaf-electrical.c"
	21	#include ".\Src\leaf.c"
	22
	23	#else
	24
	25	#include "./leaf.h"
	26	#include "./Src/leaf-math.c"
	27	#include "./Src/leaf-mempool.c"
	28	#include "./Src/leaf-tables.c"
	29	#include "./Src/leaf-distortion.c"
	30	#include "./Src/leaf-dynamics.c"
	31	#include "./Src/leaf-oscillators.c"
	32	#include "./Src/leaf-filters.c"
	33	#include "./Src/leaf-delay.c"
	34	#include "./Src/leaf-reverb.c"
	35	#include "./Src/leaf-effects.c"
	36	#include "./Src/leaf-envelopes.c"
	37	#include "./Src/leaf-analysis.c"
	38	#include "./Src/leaf-instruments.c"
	39	#include "./Src/leaf-midi.c"
	40	#include "./Src/leaf-sampling.c"
	41	#include "./Src/leaf-physical.c"
	42	#include "./Src/leaf-electrical.c"
	43	#include "./Src/leaf.c"
	44
	45	#endif

LEAF/leaf.h+14−0

@@ -1,3 +1,17 @@
		1	/** BEGIN_JUCE_MODULE_DECLARATION
		2
		3	ID: leaf
		4	vendor:
		5	version: 0.0.1
		6	name:
		7	description:
		8	website:
		9	license: Proprietary
		10
		11	dependencies:
		12
		13	END_JUCE_MODULE_DECLARATION
		14	*/
1	/*	15	/*
2	==============================================================================	16	==============================================================================
3		17

LEAF_JUCEPlugin/LEAF.jucer+1−0

@@ -76,6 +76,7 @@ · 75 unmodified lines
76	<FILE id="Oh72PT" name="leaf-electrical.c" compile="1" resource="0"	76	<FILE id="Oh72PT" name="leaf-electrical.c" compile="1" resource="0"
77	file="../LEAF/Src/leaf-electrical.c"/>	77	file="../LEAF/Src/leaf-electrical.c"/>
78	</GROUP>	78	</GROUP>
		79	<FILE id="XvFyGq" name="leaf.cpp" compile="1" resource="0" file="../LEAF/leaf.cpp"/>
79	<FILE id="dmljDQ" name="leaf.h" compile="0" resource="0" file="../LEAF/leaf.h"/>	80	<FILE id="dmljDQ" name="leaf.h" compile="0" resource="0" file="../LEAF/leaf.h"/>
80	</GROUP>	81	</GROUP>
81	<GROUP id="{FFA9F0EC-F45A-74FC-5A10-9B3CAA731E7C}" name="External">	82	<GROUP id="{FFA9F0EC-F45A-74FC-5A10-9B3CAA731E7C}" name="External">

LEAF_JUCEPlugin/Source/MyTest.cpp+1−1

@@ -202,7 +202,7 @@ static void run_pool_test(void) · 201 unmodified lines
202	{	202	{
203	buffer[i] = (float)(i*2);	203	buffer[i] = (float)(i*2);
204	}	204	}
205	leaf_free(buffer);	205	leaf_free((char*)buffer);
206		206
207	leaf_pool_report();	207	leaf_pool_report();
208		208

replace void* with char* and do explicit casts for pointers

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code

@@ -45,9 +45,9 @@ extern "C" { · 44 unmodified lines
45		45
46	float attackInc, decayInc, rampInc;	46	float attackInc, decayInc, rampInc;
47		47
48	oBool inAttack, inDecay, inRamp;	48	int inAttack, inDecay, inRamp;
49		49
50	oBool loop;	50	int loop;
51		51
52	float gain, rampPeak;	52	float gain, rampPeak;
53		53
@@ -57,15 +57,15 @@ extern "C" { · 3 unmodified lines
57		57
58	typedef _tEnvelope* tEnvelope;	58	typedef _tEnvelope* tEnvelope;
59		59
60	void tEnvelope_init (tEnvelope* const, float attack, float decay, oBool loop);	60	void tEnvelope_init (tEnvelope* const, float attack, float decay, int loop);
61	void tEnvelope_free (tEnvelope* const);	61	void tEnvelope_free (tEnvelope* const);
62	void tEnvelope_initToPool (tEnvelope* const, float attack, float decay, oBool loop, tMempool* const);	62	void tEnvelope_initToPool (tEnvelope* const, float attack, float decay, int loop, tMempool* const);
63	void tEnvelope_freeFromPool (tEnvelope* const, tMempool* const);	63	void tEnvelope_freeFromPool (tEnvelope* const, tMempool* const);
64		64
65	float tEnvelope_tick (tEnvelope* const);	65	float tEnvelope_tick (tEnvelope* const);
66	void tEnvelope_setAttack (tEnvelope* const, float attack);	66	void tEnvelope_setAttack (tEnvelope* const, float attack);
67	void tEnvelope_setDecay (tEnvelope* const, float decay);	67	void tEnvelope_setDecay (tEnvelope* const, float decay);
68	void tEnvelope_loop (tEnvelope* const, oBool loop);	68	void tEnvelope_loop (tEnvelope* const, int loop);
69	void tEnvelope_on (tEnvelope* const, float velocity);	69	void tEnvelope_on (tEnvelope* const, float velocity);
70		70
71	// ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~	71	// ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~