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

Matthew Wang committed 6 years ago

Commit 3ffbba11 parent 3f2152f26 files · +326 −262Browse files

Unified · Split

26 files

.DS_Store +0 −0
LEAF/Inc/leaf-envelopes.h +5 −5
LEAF/Inc/leaf-instruments.h +1 −1
LEAF/Inc/leaf-mempool.h +10 −10
LEAF/Inc/leaf-oscillators.h +3 −3
LEAF/Inc/leaf-tables.h +5 −1
LEAF/Src/leaf-analysis.c +22 −22
LEAF/Src/leaf-delay.c +10 −10
LEAF/Src/leaf-distortion.c +16 −16
LEAF/Src/leaf-dynamics.c +5 −5
LEAF/Src/leaf-effects.c +65 −65
LEAF/Src/leaf-electrical.c +2 −2
LEAF/Src/leaf-envelopes.c +15 −15
LEAF/Src/leaf-filters.c +30 −30
LEAF/Src/leaf-instruments.c +8 −8
LEAF/Src/leaf-math.c +2 −2
LEAF/Src/leaf-mempool.c +14 −14
LEAF/Src/leaf-midi.c +17 −17
LEAF/Src/leaf-oscillators.c +21 −21
LEAF/Src/leaf-physical.c +6 −6
LEAF/Src/leaf-reverb.c +5 −5
LEAF/Src/leaf-sampling.c +4 −4
LEAF/leaf.cpp +45 −0
LEAF/leaf.h +14 −0
LEAF_JUCEPlugin/LEAF.jucer +1 −0
LEAF_JUCEPlugin/Source/MyTest.cpp +1 −1

Binary file not shown.

@@ -45,9 +45,9 @@ extern "C" { · 44 unmodified lines
45	45
46	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	52	float gain, rampPeak;
53	53
@@ -57,15 +57,15 @@ extern "C" { · 3 unmodified lines
57	57
58	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	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	63	void tEnvelope_freeFromPool (tEnvelope* const, tMempool* const);
64	64
65	65	float tEnvelope_tick (tEnvelope* const);
66	66	void tEnvelope_setAttack (tEnvelope* const, float attack);
67	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	69	void tEnvelope_on (tEnvelope* const, float velocity);
70	70
71	71	// ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~

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

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

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

@@ -63,7 +63,7 @@ extern "C" { · 62 unmodified lines
63	63
64	64	// node of free list
65	65	typedef struct mpool_node_t {
66		− void *pool; // memory pool field
	66	+ char *pool; // memory pool field
67	67	struct mpool_node_t *next; // next node pointer
68	68	struct mpool_node_t *prev; // prev node pointer
69	69	size_t size;
@@ -71,7 +71,7 @@ extern "C" { · 1 unmodified line
71	71
72	72	typedef struct _tMempool
73	73	{
74		− void* mpool; // start of the mpool
	74	+ char* mpool; // start of the mpool
75	75	size_t usize; // used size of the pool
76	76	size_t msize; // max size of the pool
77	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	119	// typedef struct mpool_t {
120		− // void* mpool; // start of the mpool
	120	+ // char* mpool; // start of the mpool
121	121	// size_t usize; // used size of the pool
122	122	// size_t msize; // max size of the pool
123	123	// mpool_node_t* head; // first node of memory pool free list
@@ -125,25 +125,25 @@ extern "C" { · 1 unmodified line
125	125
126	126	void mpool_create (char* memory, size_t size, _tMempool* pool);
127	127
128		− void* mpool_alloc(size_t size, _tMempool* pool);
129		− void* mpool_calloc(size_t asize, _tMempool* pool);
	128	+ char* mpool_alloc(size_t size, _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	133	size_t mpool_get_size(_tMempool* pool);
134	134	size_t mpool_get_used(_tMempool* pool);
135	135
136	136	void leaf_pool_init(char* memory, size_t size);
137	137
138		− void* leaf_alloc(size_t size);
139		− void* leaf_calloc(size_t size);
	138	+ char* leaf_alloc(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	143	size_t leaf_pool_get_size(void);
144	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	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	98	// Underlying phasor
99	99	float phase;
100	100	float inc,freq;
101		− TableName oct;
	101	+ int oct;
102	102	float w;
103	103	} _tTriangle;
104	104
@@ -166,7 +166,7 @@ extern "C" { · 61 unmodified lines
166	166	// Underlying phasor
167	167	float phase;
168	168	float inc,freq;
169		− TableName oct;
	169	+ int oct;
170	170	float w;
171	171	} _tSquare;
172	172
@@ -234,7 +234,7 @@ extern "C" { · 61 unmodified lines
234	234	// Underlying phasor
235	235	float phase;
236	236	float inc,freq;
237		− TableName oct;
	237	+ int oct;
238	238	float w;
239	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	27	#define SINE_TABLE_SIZE 2048
24	28	#define SAW_TABLE_SIZE 2048
25	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	36	_tEnvelopeFollower* e = *ef;
37	37
38		− leaf_free(e);
	38	+ leaf_free((char*)e);
39	39	}
40	40
41	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	53	_tMempool* m = *mp;
54	54	_tEnvelopeFollower* e = *ef;
55	55
56		− mpool_free(e, m);
	56	+ mpool_free((char*)e, m);
57	57	}
58	58
59	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	119	_tMempool* m = *mp;
120	120	_tZeroCrossing* z = *zc;
121		− mpool_free(z->inBuffer, m);
122		− mpool_free(z->countBuffer, m);
123		− mpool_free(z, m);
	121	+ mpool_free((char*)z->inBuffer, m);
	122	+ mpool_free((char*)z->countBuffer, m);
	123	+ mpool_free((char*)z, m);
124	124	}
125	125
126	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	198	_tPowerFollower* p = *pf;
199	199
200		− leaf_free(p);
	200	+ leaf_free((char*)p);
201	201	}
202	202
203	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	215	_tMempool* m = *mp;
216	216	_tPowerFollower* p = *pf;
217	217
218		− mpool_free(p, m);
	218	+ mpool_free((char*)p, m);
219	219	}
220	220
221	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	296	_tEnvPD* x = *xpd;
297	297
298		− leaf_free(x);
	298	+ leaf_free((char*)x);
299	299	}
300	300
301	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	346	_tMempool* m = *mp;
347	347	_tEnvPD* x = *xpd;
348	348
349		− mpool_free(x, m);
	349	+ mpool_free((char*)x, m);
350	350	}
351	351
352	352	float tEnvPD_tick (tEnvPD* const xpd)
@@ -412,7 +412,7 @@ void tAttackDetection_free(tAttackDetection* const ad) · 59 unmodified lines
412	412	{
413	413	_tAttackDetection* a = *ad;
414	414
415		− leaf_free(a);
	415	+ leaf_free((char*)a);
416	416	}
417	417
418	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	428	_tMempool* m = *mp;
429	429	_tAttackDetection* a = *ad;
430	430
431		− mpool_free(a, m);
	431	+ mpool_free((char*)a, m);
432	432	}
433	433
434	434	/*****Public Functions*********/
@@ -580,11 +580,11 @@ void tSNAC_free(tSNAC* const snac) · 145 unmodified lines
580	580	{
581	581	_tSNAC* s = *snac;
582	582
583		− leaf_free(s->inputbuf);
584		− leaf_free(s->processbuf);
585		− leaf_free(s->spectrumbuf);
586		− leaf_free(s->biasbuf);
587		− leaf_free(s);
	583	+ leaf_free((char*)s->inputbuf);
	584	+ leaf_free((char*)s->processbuf);
	585	+ leaf_free((char*)s->spectrumbuf);
	586	+ leaf_free((char*)s->biasbuf);
	587	+ leaf_free((char*)s);
588	588	}
589	589
590	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	614	_tMempool* m = *mp;
615	615	_tSNAC* s = *snac;
616	616
617		− mpool_free(s->inputbuf, m);
618		− mpool_free(s->processbuf, m);
619		− mpool_free(s->spectrumbuf, m);
620		− mpool_free(s->biasbuf, m);
621		− mpool_free(s, m);
	617	+ mpool_free((char*)s->inputbuf, m);
	618	+ mpool_free((char*)s->processbuf, m);
	619	+ mpool_free((char*)s->spectrumbuf, m);
	620	+ mpool_free((char*)s->biasbuf, 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	978	tEnvPD_freeFromPool(&p->env, mp);
979	979	tSNAC_freeFromPool(&p->snac, mp);
980		− mpool_free(p, m);
	980	+ mpool_free((char*)p, m);
981	981	}
982	982
983	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	56	_tMempool* m = *mp;
57	57	_tDelay* d = *dl;
58	58
59		− mpool_free(d->buff, m);
60		− mpool_free(d, m);
	59	+ mpool_free((char*)d->buff, m);
	60	+ mpool_free((char*)d, m);
61	61	}
62	62
63	63	void tDelay_clear(tDelay* const dl)
@@ -206,8 +206,8 @@ void tLinearDelay_freeFromPool(tLinearDelay* const dl, tMempool* const mp) · 142 unmodified lines
206	206	_tMempool* m = *mp;
207	207	_tLinearDelay* d = *dl;
208	208
209		− mpool_free(d->buff, m);
210		− mpool_free(d, m);
	209	+ mpool_free((char*)d->buff, m);
	210	+ mpool_free((char*)d, m);
211	211	}
212	212
213	213	void tLinearDelay_clear(tLinearDelay* const dl)
@@ -404,8 +404,8 @@ void tHermiteDelay_freeFromPool(tHermiteDelay* const dl, tMempool* const mp) · 190 unmodified lines
404	404	_tMempool* m = *mp;
405	405	_tHermiteDelay* d = *dl;
406	406
407		− mpool_free(d->buff, m);
408		− mpool_free(d, m);
	407	+ mpool_free((char*)d->buff, 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	606	_tMempool* m = *mp;
607	607	_tAllpassDelay* d = *dl;
608	608
609		− mpool_free(d->buff, m);
610		− mpool_free(d, m);
	609	+ mpool_free((char*)d->buff, m);
	610	+ mpool_free((char*)d, m);
611	611	}
612	612
613	613	void tAllpassDelay_clear(tAllpassDelay* const dl)
@@ -781,8 +781,8 @@ void tTapeDelay_freeFromPool(tTapeDelay* const dl, tMempool* const mp) · 167 unmodified lines
781	781	_tMempool* m = *mp;
782	782	_tTapeDelay* d = *dl;
783	783
784		− mpool_free(d->buff, m);
785		− mpool_free(d, m);
	784	+ mpool_free((char*)d->buff, m);
	785	+ mpool_free((char*)d, m);
786	786	}
787	787
788	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	37	_tSampleReducer* s = *sr;
38	38
39		− leaf_free(s);
	39	+ leaf_free((char*)s);
40	40	}
41	41
42	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	54	_tMempool* m = *mp;
55	55	_tSampleReducer* s = *sr;
56	56
57		− mpool_free(s, m);
	57	+ mpool_free((char*)s, m);
58	58	}
59	59
60	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	97	os->numTaps = __leaf_tablesize_firNumTaps[idx];
98	98	os->phaseLength = os->numTaps / os->ratio;
99	99	os->pCoeffs = (float*) __leaf_tableref_firCoeffs[idx];
100		− os->upState = leaf_alloc(sizeof(float) * os->numTaps * 2);
101		− os->downState = leaf_alloc(sizeof(float) * os->numTaps * 2);
	100	+ os->upState = (float) 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	107	_tOversampler* os = *osr;
108	108
109		− leaf_free(os->upState);
110		− leaf_free(os->downState);
111		− leaf_free(os);
	109	+ leaf_free((char*)os->upState);
	110	+ leaf_free((char*)os->downState);
	111	+ leaf_free((char*)os);
112	112	}
113	113
114	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	126	os->numTaps = __leaf_tablesize_firNumTaps[idx];
127	127	os->phaseLength = os->numTaps / os->ratio;
128	128	os->pCoeffs = (float*) __leaf_tableref_firCoeffs[idx];
129		− os->upState = mpool_alloc(sizeof(float) * os->numTaps * 2, m);
130		− os->downState = mpool_alloc(sizeof(float) * os->numTaps * 2, m);
	129	+ os->upState = (float) 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	136	_tMempool* m = *mp;
137	137	_tOversampler* os = *osr;
138	138
139		− mpool_free(os->upState, m);
140		− mpool_free(os->downState, m);
141		− mpool_free(os, m);
	139	+ mpool_free((char*)os->upState, m);
	140	+ mpool_free((char*)os->downState, m);
	141	+ mpool_free((char*)os, m);
142	142	}
143	143
144	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	358	_tLockhartWavefolder* w = *wf;
359	359
360		− leaf_free(w);
	360	+ leaf_free((char*)w);
361	361	}
362	362
363	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	409	_tMempool* m = *mp;
410	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	614	_tCrusher* c = *cr;
615	615	tSampleReducer_free(&c->sReducer);
616		− leaf_free(c);
	616	+ leaf_free((char*)c);
617	617	}
618	618
619	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	634	_tMempool* m = *mp;
635	635	_tCrusher* c = *cr;
636	636	tSampleReducer_freeFromPool(&c->sReducer, mp);
637		− mpool_free(c, m);
	637	+ mpool_free((char*)c, m);
638	638	}
639	639
640	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	61	_tCompressor* c = *comp;
62	62
63		− leaf_free(c);
	63	+ leaf_free((char*)c);
64	64	}
65	65
66	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	84	_tMempool* m = *mp;
85	85	_tCompressor* c = *comp;
86	86
87		− mpool_free(c, m);
	87	+ mpool_free((char*)c, m);
88	88	}
89	89
90	90	float tCompressor_tick(tCompressor* const comp, float in)
@@ -154,7 +154,7 @@ void tFeedbackLeveler_free(tFeedbackLeveler* const fb) · 63 unmodified lines
154	154	_tFeedbackLeveler* p = *fb;
155	155
156	156	tPowerFollower_free(&p->pwrFlw);
157		− leaf_free(p);
	157	+ leaf_free((char*)p);
158	158	}
159	159
160	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	175	_tFeedbackLeveler* p = *fb;
176	176
177	177	tPowerFollower_freeFromPool(&p->pwrFlw, mp);
178		− mpool_free(p, m);
	178	+ mpool_free((char*)p, m);
179	179	}
180	180
181	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	247	_tMempool* m = *mp;
248	248	_tThreshold* t = *th;
249	249
250		− mpool_free(t, m);
	250	+ mpool_free((char*)t, m);
251	251	}
252	252
253	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	53	_tTalkbox* v = *voc;
54	54
55		− leaf_free(v->buf1);
56		− leaf_free(v->buf0);
57		− leaf_free(v->window);
58		− leaf_free(v->car1);
59		− leaf_free(v->car0);
	55	+ leaf_free((char*)v->buf1);
	56	+ leaf_free((char*)v->buf0);
	57	+ leaf_free((char*)v->window);
	58	+ leaf_free((char*)v->car1);
	59	+ leaf_free((char*)v->car0);
60	60
61		− leaf_free(v);
	61	+ leaf_free((char*)v);
62	62	}
63	63
64	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	89	_tMempool* m = *mp;
90	90	_tTalkbox* v = *voc;
91	91
92		− mpool_free(v->buf1, m);
93		− mpool_free(v->buf0, m);
94		− mpool_free(v->window, m);
95		− mpool_free(v->car1, m);
96		− mpool_free(v->car0, m);
	92	+ mpool_free((char*)v->buf1, m);
	93	+ mpool_free((char*)v->buf0, m);
	94	+ mpool_free((char*)v->window, m);
	95	+ mpool_free((char*)v->car1, 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	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	374	_tVocoder* v = *voc;
375	375
376		− leaf_free(v);
	376	+ leaf_free((char*)v);
377	377	}
378	378
379	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	398	_tMempool* m = *mp;
399	399	_tVocoder* v = *voc;
400	400
401		− mpool_free(v, m);
	401	+ mpool_free((char*)v, m);
402	402	}
403	403
404	404	void tVocoder_update (tVocoder* const voc)
@@ -591,7 +591,7 @@ void tRosenbergGlottalPulse_freeFromPool (tRosenbergGlottalPulse* const gp, · 186 unmodified lines
591	591	{
592	592	_tMempool* m = *mp;
593	593	_tRosenbergGlottalPulse* g = *gp;
594		− mpool_free(g, m);
	594	+ mpool_free((char*)g, m);
595	595	}
596	596
597	597	float tRosenbergGlottalPulse_tick (tRosenbergGlottalPulse* const gp)
@@ -675,8 +675,8 @@ void tSOLAD_free(tSOLAD* const wp) · 77 unmodified lines
675	675	{
676	676	_tSOLAD* w = *wp;
677	677
678		− leaf_free(w->delaybuf);
679		− leaf_free(w);
	678	+ leaf_free((char*)w->delaybuf);
	679	+ leaf_free((char*)w);
680	680	}
681	681
682	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	696	_tMempool* m = *mp;
697	697	_tSOLAD* w = *wp;
698	698
699		− mpool_free(w->delaybuf, m);
700		− mpool_free(w, m);
	699	+ mpool_free((char*)w->delaybuf, m);
	700	+ mpool_free((char*)w, m);
701	701	}
702	702
703	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	1060	tSOLAD_free(&ps->sola);
1061	1061	tHighpass_free(&ps->hp);
1062		− leaf_free(ps);
	1062	+ leaf_free((char*)ps);
1063	1063	}
1064	1064
1065	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	1096	tSOLAD_freeFromPool(&ps->sola, mp);
1097	1097	tHighpass_freeFromPool(&ps->hp, mp);
1098		− mpool_free(ps, m);
	1098	+ mpool_free((char*)ps, m);
1099	1099	}
1100	1100
1101	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	1269	for (int i = 0; i < r->numVoices; ++i)
1270	1270	{
1271	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);
1275		− mpool_free(r->pitchFactor, m);
1276		− mpool_free(r->ps, m);
1277		− mpool_free(r->inBuffer, m);
1278		− mpool_free(r->outBuffers, m);
1279		− mpool_free(r, m);
	1274	+ mpool_free((char*)r->tickOutput, m);
	1275	+ mpool_free((char*)r->pitchFactor, m);
	1276	+ mpool_free((char*)r->ps, m);
	1277	+ mpool_free((char*)r->inBuffer, m);
	1278	+ mpool_free((char*)r->outBuffers, m);
	1279	+ mpool_free((char*)r, m);
1280	1280	}
1281	1281
1282	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	1300	for (int i = 0; i < r->numVoices; ++i)
1301	1301	{
1302	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);
1306		− leaf_free(r->pitchFactor);
1307		− leaf_free(r->ps);
1308		− leaf_free(r->outBuffers);
	1305	+ leaf_free((char*)r->tickOutput);
	1306	+ leaf_free((char*)r->pitchFactor);
	1307	+ leaf_free((char*)r->ps);
	1308	+ leaf_free((char*)r->outBuffers);
1309	1309
1310	1310	r->numVoices = numVoices;
1311	1311
@@ -1442,14 +1442,14 @@ void tAutotune_freeFromPool (tAutotune* const rt, tMempool* const mp) · 130 unmodified lines
1442	1442	for (int i = 0; i < r->numVoices; ++i)
1443	1443	{
1444	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);
1448		− mpool_free(r->freq, m);
1449		− mpool_free(r->ps, m);
1450		− mpool_free(r->inBuffer, m);
1451		− mpool_free(r->outBuffers, m);
1452		− mpool_free(r, m);
	1447	+ mpool_free((char*)r->tickOutput, m);
	1448	+ mpool_free((char*)r->freq, m);
	1449	+ mpool_free((char*)r->ps, m);
	1450	+ mpool_free((char*)r->inBuffer, m);
	1451	+ mpool_free((char*)r->outBuffers, m);
	1452	+ mpool_free((char*)r, m);
1453	1453	}
1454	1454
1455	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	1477	for (int i = 0; i < r->numVoices; ++i)
1478	1478	{
1479	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);
1483		− leaf_free(r->freq);
1484		− leaf_free(r->ps);
1485		− leaf_free(r->outBuffers);
	1482	+ leaf_free((char*)r->tickOutput);
	1483	+ leaf_free((char*)r->freq);
	1484	+ leaf_free((char*)r->ps);
	1485	+ leaf_free((char*)r->outBuffers);
1486	1486
1487	1487	r->numVoices = numVoices;
1488	1488
@@ -1611,20 +1611,20 @@ void tFormantShifter_free(tFormantShifter* const fsr) · 122 unmodified lines
1611	1611	{
1612	1612	_tFormantShifter* fs = *fsr;
1613	1613
1614		− leaf_free(fs->fk);
1615		− leaf_free(fs->fb);
1616		− leaf_free(fs->fc);
1617		− leaf_free(fs->frb);
1618		− leaf_free(fs->frc);
1619		− leaf_free(fs->fsig);
1620		− leaf_free(fs->fsmooth);
1621		− leaf_free(fs->ftvec);
1622		− leaf_free(fs->fbuff);
	1614	+ leaf_free((char*)fs->fk);
	1615	+ leaf_free((char*)fs->fb);
	1616	+ leaf_free((char*)fs->fc);
	1617	+ leaf_free((char*)fs->frb);
	1618	+ leaf_free((char*)fs->frc);
	1619	+ leaf_free((char*)fs->fsig);
	1620	+ leaf_free((char*)fs->fsmooth);
	1621	+ leaf_free((char*)fs->ftvec);
	1622	+ leaf_free((char*)fs->fbuff);
1623	1623	tHighpass_free(&fs->hp);
1624	1624	tHighpass_free(&fs->hp2);
1625	1625	tFeedbackLeveler_free(&fs->fbl1);
1626	1626	tFeedbackLeveler_free(&fs->fbl2);
1627		− leaf_free(fs);
	1627	+ leaf_free((char*)fs);
1628	1628	}
1629	1629
1630	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	1666	_tMempool* m = *mp;
1667	1667	_tFormantShifter* fs = *fsr;
1668	1668
1669		− mpool_free(fs->fk, m);
1670		− mpool_free(fs->fb, m);
1671		− mpool_free(fs->fc, m);
1672		− mpool_free(fs->frb, m);
1673		− mpool_free(fs->frc, m);
1674		− mpool_free(fs->fsig, m);
1675		− mpool_free(fs->fsmooth, m);
1676		− mpool_free(fs->ftvec, m);
1677		− mpool_free(fs->fbuff, m);
	1669	+ mpool_free((char*)fs->fk, m);
	1670	+ mpool_free((char*)fs->fb, m);
	1671	+ mpool_free((char*)fs->fc, m);
	1672	+ mpool_free((char*)fs->frb, m);
	1673	+ mpool_free((char*)fs->frc, m);
	1674	+ mpool_free((char*)fs->fsig, m);
	1675	+ mpool_free((char*)fs->fsmooth, m);
	1676	+ mpool_free((char*)fs->ftvec, m);
	1677	+ mpool_free((char*)fs->fbuff, m);
1678	1678	tHighpass_freeFromPool(&fs->hp, mp);
1679	1679	tHighpass_freeFromPool(&fs->hp2, mp);
1680	1680	tFeedbackLeveler_freeFromPool(&fs->fbl1, mp);
1681	1681	tFeedbackLeveler_freeFromPool(&fs->fbl2, mp);
1682		− mpool_free(fs, m);
	1682	+ mpool_free((char*)fs, m);
1683	1683	}
1684	1684
1685	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	176	_tWDF* r = *wdf;
177	177
178		− leaf_free(r);
	178	+ leaf_free((char*)r);
179	179	}
180	180
181	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	191	_tMempool* m = *mp;
192	192	_tWDF* r = *wdf;
193	193
194		− mpool_free(r, m);
	194	+ mpool_free((char*)r, m);
195	195	}
196	196
197	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	24	#endif
25	25
26	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	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	67	void tEnvelope_free(tEnvelope* const envlp)
68	68	{
69	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	75	_tMempool* m = *mp;
76	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	116	_tMempool* m = *mp;
117	117	_tEnvelope* env = *envlp;
118		− mpool_free(env, m);
	118	+ mpool_free((char*)env, m);
119	119	}
120	120
121	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	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	157	_tEnvelope* env = *envlp;
158	158	env->loop = loop;
@@ -331,7 +331,7 @@ void tADSR_freeFromPool (tADSR* const adsrenv, tMempool* const mp) · 172 unmodified lines
331	331	{
332	332	_tMempool* m = *mp;
333	333	_tADSR* adsr = *adsrenv;
334		− mpool_free(adsr, m);
	334	+ mpool_free((char*)adsr, m);
335	335	}
336	336
337	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	588	_tMempool* m = *mp;
589	589	_tADSR2* adsr = *adsrenv;
590		− mpool_free(adsr, m);
	590	+ mpool_free((char*)adsr, m);
591	591	}
592	592
593	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	746	_tMempool* m = *mp;
747	747	_tADSR3* adsr = *adsrenv;
748		− mpool_free(adsr, m);
	748	+ mpool_free((char*)adsr, m);
749	749	}
750	750
751	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	904	_tMempool* m = *mp;
905	905	_tADSR4* adsr = *adsrenv;
906		− mpool_free(adsr, m);
	906	+ mpool_free((char*)adsr, m);
907	907	}
908	908
909	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	1228	_tRamp* ramp = *r;
1229	1229
1230		− leaf_free(ramp);
	1230	+ leaf_free((char*)ramp);
1231	1231	}
1232	1232
1233	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	1258	_tMempool* m = *mp;
1259	1259	_tRamp* ramp = *r;
1260	1260
1261		− mpool_free(ramp, m);
	1261	+ mpool_free((char*)ramp, m);
1262	1262	}
1263	1263
1264	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	1372	_tMempool* m = *mp;
1373	1373	_tRampUpDown* ramp = *r;
1374	1374
1375		− mpool_free(ramp, m);
	1375	+ mpool_free((char*)ramp, m);
1376	1376	}
1377	1377
1378	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	1485	_tExpSmooth* smooth = *expsmooth;
1486	1486
1487		− leaf_free(smooth);
	1487	+ leaf_free((char*)smooth);
1488	1488	}
1489	1489
1490	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	1505	_tMempool* m = *mp;
1506	1506	_tExpSmooth* smooth = *expsmooth;
1507	1507
1508		− mpool_free(smooth, m);
	1508	+ mpool_free((char*)smooth, m);
1509	1509	}
1510	1510
1511	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	1588	_tMempool* m = *mp;
1589	1589	_tSlide* s = *sl;
1590	1590
1591		− mpool_free(s, m);
	1591	+ mpool_free((char*)s, m);
1592	1592	}
1593	1593
1594	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	37	_tAllpass* f = *ft;
38	38
39	39	tLinearDelay_free(&f->delay);
40		− leaf_free(f);
	40	+ leaf_free((char*)f);
41	41	}
42	42
43	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	58	_tAllpass* f = *ft;
59	59
60	60	tLinearDelay_freeFromPool(&f->delay, mp);
61		− mpool_free(f, m);
	61	+ mpool_free((char*)f, m);
62	62	}
63	63
64	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	107	_tOnePole* f = *ft;
108	108
109		− leaf_free(f);
	109	+ leaf_free((char*)f);
110	110	}
111	111
112	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	128	_tMempool* m = *mp;
129	129	_tOnePole* f = *ft;
130	130
131		− mpool_free(f, m);
	131	+ mpool_free((char*)f, m);
132	132	}
133	133
134	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	210	_tTwoPole* f = *ft;
211	211
212		− leaf_free(f);
	212	+ leaf_free((char*)f);
213	213	}
214	214
215	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	230	_tMempool* m = *mp;
231	231	_tTwoPole* f = *ft;
232	232
233		− mpool_free(f, m);
	233	+ mpool_free((char*)f, m);
234	234	}
235	235
236	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	336	_tOneZero* f = *ft;
337	337
338		− leaf_free(f);
	338	+ leaf_free((char*)f);
339	339	}
340	340
341	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	354	_tMempool* m = *mp;
355	355	_tOneZero* f = *ft;
356	356
357		− mpool_free(f, m);
	357	+ mpool_free((char*)f, m);
358	358	}
359	359
360	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	451	_tTwoZero* f = *ft;
452	452
453		− leaf_free(f);
	453	+ leaf_free((char*)f);
454	454	}
455	455
456	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	468	_tMempool* m = *mp;
469	469	_tTwoZero* f = *ft;
470	470
471		− mpool_free(f, m);
	471	+ mpool_free((char*)f, m);
472	472	}
473	473
474	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	559	_tPoleZero* f = *pzf;
560	560
561		− leaf_free(f);
	561	+ leaf_free((char*)f);
562	562	}
563	563
564	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	579	_tMempool* m = *mp;
580	580	_tPoleZero* f = *pzf;
581	581
582		− mpool_free(f, m);
	582	+ mpool_free((char*)f, m);
583	583	}
584	584
585	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	690	_tBiQuad* f = *ft;
691	691
692		− leaf_free(f);
	692	+ leaf_free((char*)f);
693	693	}
694	694
695	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	713	_tMempool* m = *mp;
714	714	_tBiQuad* f = *ft;
715	715
716		− mpool_free(f, m);
	716	+ mpool_free((char*)f, m);
717	717	}
718	718
719	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	923	_tMempool* m = *mp;
924	924	_tSVF* svf = *svff;
925	925
926		− mpool_free(svf, m);
	926	+ mpool_free((char*)svf, m);
927	927	}
928	928
929	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	993	_tEfficientSVF* svf = *svff;
994	994
995		− leaf_free(svf);
	995	+ leaf_free((char*)svf);
996	996	}
997	997
998	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	1017	_tMempool* m = *mp;
1018	1018	_tEfficientSVF* svf = *svff;
1019	1019
1020		− mpool_free(svf, m);
	1020	+ mpool_free((char*)svf, m);
1021	1021	}
1022	1022
1023	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	1077	_tHighpass* f = *ft;
1078	1078
1079		− leaf_free(f);
	1079	+ leaf_free((char*)f);
1080	1080	}
1081	1081
1082	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	1096	_tMempool* m = *mp;
1097	1097	_tHighpass* f = *ft;
1098	1098
1099		− mpool_free(f, m);
	1099	+ mpool_free((char*)f, m);
1100	1100	}
1101	1101
1102	1102	void tHighpass_setFreq(tHighpass* const ft, float freq)
@@ -1157,7 +1157,7 @@ void tButterworth_free(tButterworth* const ft) · 54 unmodified lines
1157	1157	tSVF_free(&f->high[i]);
1158	1158	}
1159	1159
1160		− leaf_free(f);
	1160	+ leaf_free((char*)f);
1161	1161	}
1162	1162
1163	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	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	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	1250	_tFIR* fir = *firf;
1251	1251
1252		− leaf_free(fir->past);
1253		− leaf_free(fir);
	1252	+ leaf_free((char*)fir->past);
	1253	+ leaf_free((char*)fir);
1254	1254	}
1255	1255
1256	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	1269	_tMempool* m = *mp;
1270	1270	_tFIR* fir = *firf;
1271	1271
1272		− mpool_free(fir->past, m);
1273		− mpool_free(fir, m);
	1272	+ mpool_free((char*)fir->past, m);
	1273	+ mpool_free((char*)fir, m);
1274	1274	}
1275	1275
1276	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	1321	_tMempool* m = *mp;
1322	1322	_tMedianFilter* f = *mf;
1323	1323
1324		− mpool_free(f->val, m);
1325		− mpool_free(f->age, m);
1326		− mpool_free(f, m);
	1324	+ mpool_free((char*)f->val, m);
	1325	+ mpool_free((char*)f->age, m);
	1326	+ mpool_free((char*)f, m);
1327	1327	}
1328	1328
1329	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	1400	_tMempool* m = *mp;
1401	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	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	1700	_tMempool* m = *mp;
1701	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	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	60	tHighpass_free(&cowbell->highpass);
61	61	tNoise_free(&cowbell->stick);
62	62	tEnvelope_free(&cowbell->envStick);
63		− leaf_free(cowbell);
	63	+ leaf_free((char*)cowbell);
64	64	}
65	65
66	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	107	tHighpass_freeFromPool(&cowbell->highpass, mp);
108	108	tNoise_freeFromPool(&cowbell->stick, mp);
109	109	tEnvelope_freeFromPool(&cowbell->envStick, mp);
110		− mpool_free(cowbell, m);
	110	+ mpool_free((char*)cowbell, m);
111	111	}
112	112
113	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	237	tHighpass_free(&hihat->highpass);
238	238
239		− leaf_free(hihat);
	239	+ leaf_free((char*)hihat);
240	240	}
241	241
242	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	295	tHighpass_freeFromPool(&hihat->highpass, mp);
296	296
297		− mpool_free(hihat, m);
	297	+ mpool_free((char*)hihat, m);
298	298	}
299	299
300	300	void t808Hihat_on(t808Hihat* const hihatInst, float vel)
@@ -448,7 +448,7 @@ void t808Snare_free (t808Snare* const snareInst) · 147 unmodified lines
448	448	tEnvelope_free(&snare->noiseEnvGain);
449	449	tEnvelope_free(&snare->noiseEnvFilter);
450	450
451		− leaf_free(snare);
	451	+ leaf_free((char*)snare);
452	452	}
453	453
454	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	499	tEnvelope_freeFromPool(&snare->noiseEnvGain, mp);
500	500	tEnvelope_freeFromPool(&snare->noiseEnvFilter, mp);
501	501
502		− mpool_free(snare, m);
	502	+ mpool_free((char*)snare, m);
503	503	}
504	504
505	505	void t808Snare_on(t808Snare* const snareInst, float vel)
@@ -623,7 +623,7 @@ void t808Kick_free (t808Kick* const kickInst) · 117 unmodified lines
623	623	tNoise_free(&kick->noiseOsc);
624	624	tEnvelope_free(&kick->noiseEnvGain);
625	625
626		− leaf_free(kick);
	626	+ leaf_free((char*)kick);
627	627	}
628	628
629	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	658	tNoise_freeFromPool(&kick->noiseOsc, mp);
659	659	tEnvelope_freeFromPool(&kick->noiseEnvGain, mp);
660	660
661		− mpool_free(kick, m);
	661	+ mpool_free((char*)kick, m);
662	662	}
663	663
664	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	127	if (x >= -127.0)
128	128	{
129		− register float accumulator, xPower;
130		− register union {float f; int32_t i;} xBits;
	129	+ float accumulator, xPower;
	130	+ union {float f; int32_t i;} xBits;
131	131
132	132	xBits.i = (int32_t)(x + 4096.0f) - 4096L; /* integer part */
133	133	x -= (float)(xBits.i); /* fractional part */

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

@@ -52,7 +52,7 @@ · 51 unmodified lines
52	52	* private function
53	53	*/
54	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	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	63	leaf.header_size = mpool_align(sizeof(mpool_node_t));
64	64
65		− pool->mpool = (void*)memory;
	65	+ pool->mpool = (char*)memory;
66	66	pool->usize = 0;
67	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	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	92	// If the head is NULL, the mempool is full
93	93	if (pool->head == NULL)
@@ -161,7 +161,7 @@ void* mpool_alloc(size_t asize, _tMempool* pool) · 67 unmodified lines
161	161	/**
162	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	166	// If the head is NULL, the mempool is full
167	167	if (pool->head == NULL)
@@ -227,20 +227,20 @@ void* mpool_calloc(size_t asize, _tMempool* pool) · 59 unmodified lines
227	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	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	235	if (block == NULL) leaf_mempool_overrun();
236	236
237	237	return block;
238	238	}
239	239
240		−void* leaf_calloc(size_t size)
	240	+char* leaf_calloc(size_t size)
241	241	{
242	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	245	if (block == NULL) leaf_mempool_overrun();
246	246
@@ -248,7 +248,7 @@ void* leaf_calloc(size_t size) · 1 unmodified line
248	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	253	//if (ptr < pool->mpool \|\| ptr >= pool->mpool + pool->msize)
254	254	// Get the node at the freed space
@@ -310,7 +310,7 @@ void mpool_free(void* ptr, _tMempool* pool) · 55 unmodified lines
310	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	315	mpool_free(ptr, &leaf._mempool);
316	316	}
@@ -335,9 +335,9 @@ size_t leaf_pool_get_used(void) · 18 unmodified lines
335	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	342	return buff;
343	343	}
@@ -349,7 +349,7 @@ static inline size_t mpool_align(size_t size) { · 5 unmodified lines
349	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	354	mpool_node_t* node = (mpool_node_t*)block_location;
355	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	408	_tMempool* mm = *mem;
409	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	37	_tStack* ns = *stack;
38	38
39		− leaf_free(ns);
	39	+ leaf_free((char*)ns);
40	40	}
41	41
42	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	57	_tMempool* m = *mp;
58	58	_tStack* ns = *stack;
59	59
60		− mpool_free(ns, m);
	60	+ mpool_free((char*)ns, m);
61	61	}
62	62
63	63	// If stack contains note, returns index. Else returns -1;
@@ -322,18 +322,18 @@ void tPoly_free(tPoly* const polyh) · 258 unmodified lines
322	322	for (int i = 0; i < poly->maxNumVoices; i++)
323	323	{
324	324	tRamp_free(&poly->ramps[i]);
325		− leaf_free(poly->voices[i]);
	325	+ leaf_free((char*)poly->voices[i]);
326	326	}
327	327	tRamp_free(&poly->pitchBendRamp);
328	328	tStack_free(&poly->stack);
329	329	tStack_free(&poly->orderStack);
330	330
331		− leaf_free(poly->voices);
332		− leaf_free(poly->ramps);
333		− leaf_free(poly->rampVals);
334		− leaf_free(poly->firstReceived);
	331	+ leaf_free((char*)poly->voices);
	332	+ leaf_free((char*)poly->ramps);
	333	+ leaf_free((char*)poly->rampVals);
	334	+ leaf_free((char*)poly->firstReceived);
335	335
336		− leaf_free(poly);
	336	+ leaf_free((char*)poly);
337	337	}
338	338
339	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	390	for (int i = 0; i < poly->maxNumVoices; i++)
391	391	{
392	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	395	tRamp_freeFromPool(&poly->pitchBendRamp, mp);
396	396	tStack_freeFromPool(&poly->stack, mp);
397	397	tStack_freeFromPool(&poly->orderStack, mp);
398	398
399		− mpool_free(poly->voices, m);
400		− mpool_free(poly->ramps, m);
401		− mpool_free(poly->rampVals, m);
402		− mpool_free(poly->firstReceived, m);
	399	+ mpool_free((char*)poly->voices, m);
	400	+ mpool_free((char*)poly->ramps, m);
	401	+ mpool_free((char*)poly->rampVals, 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	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	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	735	tStack_freeFromPool(&poly->stack, mp);
736		− mpool_free(poly->voices, m);
737		− mpool_free(poly, m);
	736	+ mpool_free((char*)poly->voices, m);
	737	+ mpool_free((char*)poly, m);
738	738	}
739	739
740	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	42	_tMempool* m = *mp;
43	43	_tCycle* c = *cy;
44	44
45		− mpool_free(c, m);
	45	+ mpool_free((char*)c, m);
46	46	}
47	47
48	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	116	_tMempool* m = *mp;
117	117	_tTriangle* c = *cy;
118	118
119		− mpool_free(c, m);
	119	+ mpool_free((char*)c, m);
120	120	}
121	121
122	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	190	_tMempool* m = *mp;
191	191	_tSquare* c = *cy;
192	192
193		− mpool_free(c, m);
	193	+ mpool_free((char*)c, m);
194	194	}
195	195
196	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	263	_tMempool* m = *mp;
264	264	_tSawtooth* c = *cy;
265	265
266		− mpool_free(c, m);
	266	+ mpool_free((char*)c, m);
267	267	}
268	268
269	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	338	_tMempool* m = *mp;
339	339	_tSine* c = *cy;
340	340
341		− mpool_free(c->sine, m);
342		− mpool_free(c, m);
	341	+ mpool_free((char*)c->sine, m);
	342	+ mpool_free((char*)c, m);
343	343	}
344	344
345	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	413	_tMempool* m = *mp;
414	414	_tTri* c = *cy;
415	415
416		− mpool_free(c, m);
	416	+ mpool_free((char*)c, m);
417	417	}
418	418
419	419	float tTri_tick (tTri* const osc)
@@ -492,7 +492,7 @@ void tPulse_freeFromPool(tPulse* const osc, tMempool* const mp) · 72 unmodified lines
492	492	_tMempool* m = *mp;
493	493	_tPulse* c = *osc;
494	494
495		− mpool_free(c, m);
	495	+ mpool_free((char*)c, m);
496	496	}
497	497
498	498	float tPulse_tick (tPulse* const osc)
@@ -556,7 +556,7 @@ void tSaw_freeFromPool (tSaw* const osc, tMempool* const mp) · 57 unmodified lines
556	556	_tMempool* m = *mp;
557	557	_tSaw* c = *osc;
558	558
559		− mpool_free(c, m);
	559	+ mpool_free((char*)c, m);
560	560	}
561	561
562	562	float tSaw_tick (tSaw* const osc)
@@ -618,7 +618,7 @@ void tPhasor_freeFromPool(tPhasor* const ph, tMempool* const mp) · 55 unmodified lines
618	618	_tMempool* m = *mp;
619	619	_tPhasor* p = *ph;
620	620
621		− mpool_free(p, m);
	621	+ mpool_free((char*)p, m);
622	622	}
623	623
624	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	672	_tMempool* m = *mp;
673	673	_tNoise* n = *ns;
674	674
675		− mpool_free(n, m);
	675	+ mpool_free((char*)n, m);
676	676	}
677	677
678	678	float tNoise_tick(tNoise* const ns)
@@ -752,7 +752,7 @@ void tNeuron_freeFromPool(tNeuron* const nr, tMempool* const mp) · 73 unmodified lines
752	752	_tNeuron* n = *nr;
753	753
754	754	tPoleZero_free(&n->f);
755		− mpool_free(n, m);
	755	+ mpool_free((char*)n, m);
756	756	}
757	757
758	758	void tNeuron_reset(tNeuron* const nr)
@@ -981,15 +981,15 @@ void tMinBLEP_freeFromPool (tMinBLEP* const minblep, tMempool* const mp) · 222 unmodified lines
981	981	_tMempool* m = *mp;
982	982	_tMinBLEP* mb = *minblep;
983	983
984		− mpool_free(mb->offset, m);
	984	+ mpool_free((char*)mb->offset, m);
985	985	// mpool_free(mb->freqMultiple, m);
986		− mpool_free(mb->pos_change_magnitude, m);
987		− mpool_free(mb->vel_change_magnitude, m);
	986	+ mpool_free((char*)mb->pos_change_magnitude, m);
	987	+ mpool_free((char*)mb->vel_change_magnitude, m);
988	988
989		− mpool_free(mb->minBlepArray, m);
990		− mpool_free(mb->minBlepDerivArray, m);
	989	+ mpool_free((char*)mb->minBlepArray, 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	995	// SINC Function
@@ -1382,7 +1382,7 @@ void tMBTriangle_freeFromPool (tMBTriangle* const cy, tMempool* const mp) · 386 unmodified lines
1382	1382	tMinBLEP_freeFromPool(&c->minBlep, mp);
1383	1383	tHighpass_freeFromPool(&c->dcBlock, mp);
1384	1384
1385		− mpool_free(c, m);
	1385	+ mpool_free((char*)c, m);
1386	1386	}
1387	1387
1388	1388	float tMBTriangle_tick (tMBTriangle* const osc)
@@ -1521,7 +1521,7 @@ void tMBPulse_freeFromPool(tMBPulse* const osc, tMempool* const mp) · 132 unmodified lines
1521	1521	tMinBLEP_freeFromPool(&c->minBlep, mp);
1522	1522	tHighpass_freeFromPool(&c->dcBlock, mp);
1523	1523
1524		− mpool_free(c, m);
	1524	+ mpool_free((char*)c, m);
1525	1525	}
1526	1526
1527	1527	float tMBPulse_tick (tMBPulse* const osc)
@@ -1618,7 +1618,7 @@ void tMBSaw_freeFromPool (tMBSaw* const osc, tMempool* const mp) · 90 unmodified lines
1618	1618	tMinBLEP_freeFromPool(&c->minBlep, mp);
1619	1619	tHighpass_freeFromPool(&c->dcBlock, mp);
1620	1620
1621		− mpool_free(c, m);
	1621	+ mpool_free((char*)c, m);
1622	1622	}
1623	1623
1624	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	56	tOneZero_freeFromPool(&p->loopFilter, mp);
57	57	tAllpassDelay_freeFromPool(&p->delayLine, mp);
58	58
59		− mpool_free(p, m);
	59	+ mpool_free((char*)p, m);
60	60	}
61	61
62	62	float tPluck_getLastOut (tPluck* const pl)
@@ -194,7 +194,7 @@ void tKarplusStrong_freeFromPool (tKarplusStrong* const pl, tMempool* const m · 131 unmodified lines
194	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	200	float tKarplusStrong_getLastOut (tKarplusStrong* const pl)
@@ -396,7 +396,7 @@ void tSimpleLivingString_freeFromPool (tSimpleLivingString* const pl, tMem · 195 unmodified lines
396	396	tHighpass_freeFromPool(&p->DCblocker, mp);
397	397	tFeedbackLeveler_freeFromPool(&p->fbLev, mp);
398	398
399		− mpool_free(p, m);
	399	+ mpool_free((char*)p, m);
400	400	}
401	401
402	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	544	tFeedbackLeveler_freeFromPool(&p->fbLevU, mp);
545	545	tFeedbackLeveler_freeFromPool(&p->fbLevL, mp);
546	546
547		− mpool_free(p, m);
	547	+ mpool_free((char*)p, m);
548	548	}
549	549
550	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	684	_tReedTable* p = *pm;
685	685
686		− leaf_free(p);
	686	+ leaf_free((char*)p);
687	687	}
688	688
689	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	700	_tMempool* m = *mp;
701	701	_tReedTable* p = *pm;
702	702
703		− mpool_free(p, m);
	703	+ mpool_free((char*)p, m);
704	704	}
705	705
706	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	62	tDelay_free(&r->allpassDelays[0]);
63	63	tDelay_free(&r->allpassDelays[1]);
64	64	tDelay_free(&r->combDelay);
65		− leaf_free(r);
	65	+ leaf_free((char*)r);
66	66	}
67	67
68	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	110	tDelay_freeFromPool(&r->allpassDelays[0], mp);
111	111	tDelay_freeFromPool(&r->allpassDelays[1], mp);
112	112	tDelay_freeFromPool(&r->combDelay, mp);
113		− mpool_free(r, m);
	113	+ mpool_free((char*)r, m);
114	114	}
115	115
116	116	void tPRCRevert_clear(tPRCReverb* const rev)
@@ -237,7 +237,7 @@ void tNReverb_free(tNReverb* const rev) · 120 unmodified lines
237	237	tLinearDelay_free(&r->allpassDelays[i]);
238	238	}
239	239
240		− leaf_free(r);
	240	+ leaf_free((char*)r);
241	241	}
242	242
243	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	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	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	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	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	53	_tMempool* m = *mp;
54	54	_tBuffer* s = *sb;
55	55
56		− mpool_free(s->buff, m);
57		− mpool_free(s, m);
	56	+ mpool_free((char*)s->buff, m);
	57	+ mpool_free((char*)s, m);
58	58	}
59	59
60	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	206	_tSampler* p = *sp;
207	207	tRamp_freeFromPool(&p->gain, mp);
208	208
209		− mpool_free(p, m);
	209	+ mpool_free((char*)p, m);
210	210	}
211	211
212	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	768	tEnvelopeFollower_freeFromPool(&a->ef, mp);
769	769	tSampler_freeFromPool(&a->sampler, mp);
770	770
771		− mpool_free(a, m);
	771	+ mpool_free((char*)a, m);
772	772	}
773	773
774	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	76	<FILE id="Oh72PT" name="leaf-electrical.c" compile="1" resource="0"
77	77	file="../LEAF/Src/leaf-electrical.c"/>
78	78	</GROUP>
	79	+ <FILE id="XvFyGq" name="leaf.cpp" compile="1" resource="0" file="../LEAF/leaf.cpp"/>
79	80	<FILE id="dmljDQ" name="leaf.h" compile="0" resource="0" file="../LEAF/leaf.h"/>
80	81	</GROUP>
81	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	203	buffer[i] = (float)(i*2);
204	204	}
205		− leaf_free(buffer);
	205	+ leaf_free((char*)buffer);
206	206
207	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