reduced mempool size and removed variable count

Matthew Wang committed 7 years ago

Commit d4077051 parent 91710622 files · +186 −188Browse files

Unified · Split

2 files

LEAF/Inc/leaf-mempool.h +25 −25
LEAF/Src/leaf-delay.c +161 −163

@@ -1,5 +1,5 @@
1		−/*==============================================================================
2		−
	1	+/*==============================================================================
	2	+
3	3	In short, mpool is distributed under so called "BSD license",
4	4
5	5	Copyright (c) 2009-2010 Tatsuhiko Kubo <cubicdaiya@gmail.com>
@@ -29,31 +29,31 @@ · 23 unmodified lines
29	29	PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
30	30	LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
31	31	NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
32		− SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
33		−
	32	+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	33	+
34	34	written by C99 style
35	35	==============================================================================*/
36	36
37	37	#ifndef LEAF_MPOOL_H_INCLUDED
38		−#define LEAF_MPOOL_H_INCLUDED
39		−
40		−#ifdef __cplusplus
41		−extern "C" {
42		−#endif
43		−
	38	+#define LEAF_MPOOL_H_INCLUDED
	39	+
	40	+#ifdef __cplusplus
	41	+extern "C" {
	42	+#endif
	43	+
44	44	//==============================================================================
45	45
46	46	#include <stdio.h>
47	47	#include <stdlib.h>
48	48	#include <string.h>
49		−#include <stdbool.h>
50		−
	49	+#include <stdbool.h>
	50	+
51	51	//==============================================================================
52	52
53		−
54		−#define MPOOL_POOL_SIZE 500000
55		−
56		−#define MPOOL_ALIGN_SIZE (8)
	53	+
	54	+#define MPOOL_POOL_SIZE 50000
	55	+
	56	+#define MPOOL_ALIGN_SIZE (8)
57	57
58	58	//#define size_t unsigned long
59	59
@@ -92,18 +92,18 @@ void leaf_free(void* ptr); · 32 unmodified lines
92	92	size_t leaf_pool_get_size(void);
93	93	size_t leaf_pool_get_used(void);
94	94
95		−void* leaf_pool_get_pool(void);
96		−
97		−void leaf_mempool_overrun(void);
98		−
	95	+void* leaf_pool_get_pool(void);
	96	+
	97	+void leaf_mempool_overrun(void);
	98	+
99	99	//==============================================================================
100		−
101		−#ifdef __cplusplus
102		−}
	100	+
	101	+#ifdef __cplusplus
	102	+}
103	103	#endif
104	104
105		−#endif // LEAF_MPOOL_H
106		−
	105	+#endif // LEAF_MPOOL_H
	106	+
107	107	//==============================================================================
108	108
109	109

LEAF/Src/leaf-delay.c+161−163

@@ -61,7 +61,7 @@ float tDelay_tick (tDelay* const d, float input) · 60 unmodified lines
61	61
62	62	int tDelay_setDelay (tDelay* const d, uint32_t delay)
63	63	{
64		− d->delay = LEAF_clip(0.0f, delay, d->maxDelay);
	64	+ d->delay = LEAF_clip(0.0f, delay, d->maxDelay);
65	65
66	66
67	67	// read chases write
@@ -161,15 +161,15 @@ float tDelayL_tick (tDelayL* const d, float input) · 93 unmodified lines
161	161	d->buff[d->inPoint] = input * d->gain;
162	162
163	163	// Increment input pointer modulo length.
164		− if (++(d->inPoint) == d->maxDelay ) d->inPoint = 0;
165		−
166		−
167		− uint32_t idx = (uint32_t) d->outPoint;
168		−
169		− d->lastOut = LEAF_interpolate_hermite (d->buff[((idx - 1) + d->maxDelay) % d->maxDelay],
170		− d->buff[idx],
171		− d->buff[(idx + 1) % d->maxDelay],
172		− d->buff[(idx + 2) % d->maxDelay],
	164	+ if (++(d->inPoint) == d->maxDelay ) d->inPoint = 0;
	165	+
	166	+
	167	+ uint32_t idx = (uint32_t) d->outPoint;
	168	+
	169	+ d->lastOut = LEAF_interpolate_hermite (d->buff[((idx - 1) + d->maxDelay) % d->maxDelay],
	170	+ d->buff[idx],
	171	+ d->buff[(idx + 1) % d->maxDelay],
	172	+ d->buff[(idx + 2) % d->maxDelay],
173	173	d->alpha);
174	174
175	175	// Increment output pointer modulo length
@@ -203,7 +203,7 @@ float tDelayL_tickOut (tDelayL* const d) · 27 unmodified lines
203	203	}
204	204
205	205	int tDelayL_setDelay (tDelayL* const d, float delay)
206		−{
	206	+{
207	207	d->delay = LEAF_clip(0.0f, delay, d->maxDelay);
208	208
209	209	float outPointer = d->inPoint - d->delay;
@@ -226,20 +226,20 @@ float tDelayL_tapOut (tDelayL* const d, float tapDelay) · 16 unmodified lines
226	226	float tap = (float) d->inPoint - tapDelay - 1.f;
227	227
228	228	// Check for wraparound.
229		− while ( tap < 0.f ) tap += (float)d->maxDelay;
230		−
231		− float alpha = tap - (int)tap;
232		− float omAlpha = 1.f - alpha;
233		−
234		− int ptx = (int) tap;
235		−
236		− // First 1/2 of interpolation
237		− float samp = d->buff[ptx] * omAlpha;
238		−
239		− // Second 1/2 of interpolation
240		− if ((ptx + 1) < d->maxDelay)
241		− samp += d->buff[ptx+1] * d->alpha;
242		− else
	229	+ while ( tap < 0.f ) tap += (float)d->maxDelay;
	230	+
	231	+ float alpha = tap - (int)tap;
	232	+ float omAlpha = 1.f - alpha;
	233	+
	234	+ int ptx = (int) tap;
	235	+
	236	+ // First 1/2 of interpolation
	237	+ float samp = d->buff[ptx] * omAlpha;
	238	+
	239	+ // Second 1/2 of interpolation
	240	+ if ((ptx + 1) < d->maxDelay)
	241	+ samp += d->buff[ptx+1] * d->alpha;
	242	+ else
243	243	samp += d->buff[0] * d->alpha;
244	244
245	245	return samp;
@@ -345,7 +345,7 @@ float tDelayA_tick (tDelayA* const d, float input) · 99 unmodified lines
345	345
346	346	int tDelayA_setDelay (tDelayA* const d, float delay)
347	347	{
348		− d->delay = LEAF_clip(0.5f, delay, d->maxDelay);
	348	+ d->delay = LEAF_clip(0.5f, delay, d->maxDelay);
349	349
350	350
351	351	// outPoint chases inPoint
@@ -431,142 +431,140 @@ void tDelayA_setGain (tDelayA* const d, float gain) · 79 unmodified lines
431	431	float tDelayA_getGain (tDelayA* const d)
432	432	{
433	433	return d->gain;
434		−}
435		−
436		−// ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ TapeDelay ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ //
437		−void tTapeDelay_init (tTapeDelay* const d, float delay, uint32_t maxDelay)
438		−{
439		− d->maxDelay = maxDelay;
440		−
441		− d->buff = (float) leaf_alloc(sizeof(float) maxDelay);
442		−
443		− d->gain = 1.0f;
444		−
445		− d->lastIn = 0.0f;
446		− d->lastOut = 0.0f;
447		−
448		− d->idx = 0.0f;
449		− d->inc = 1.0f;
450		− d->inPoint = 0;
451		−
452		− tTapeDelay_setDelay(d, delay);
453		−}
454		−
455		−void tTapeDelay_free(tTapeDelay* const d)
456		−{
457		− leaf_free(d->buff);
458		− leaf_free(d);
459		−}
460		−
461		−int count = 0;
462		−
463		−//#define SMOOTH_FACTOR 10.f
464		−
465		−float tTapeDelay_tick (tTapeDelay* const d, float input)
466		−{
467		− d->buff[d->inPoint] = input * d->gain;
468		−
469		− // Increment input pointer modulo length.
470		− if (++(d->inPoint) == d->maxDelay ) d->inPoint = 0;
471		−
472		− int idx = (int) d->idx;
473		− float alpha = d->idx - idx;
474		−
475		− d->lastOut = LEAF_interpolate_hermite (d->buff[((idx - 1) + d->maxDelay) % d->maxDelay],
476		− d->buff[idx],
477		− d->buff[(idx + 1) % d->maxDelay],
478		− d->buff[(idx + 2) % d->maxDelay],
479		− alpha);
480		−
481		− float diff = (d->inPoint - d->idx);
482		− while (diff < 0.f) diff += d->maxDelay;
483		−
484		− d->inc = 1.0f + (diff - d->delay) / d->delay; //* SMOOTH_FACTOR;
485		−
486		− d->idx += d->inc;
487		−
488		− if (d->idx >= d->maxDelay) d->idx = 0.0f;
489		−
490		− return d->lastOut;
491		−}
492		−
493		−
494		−void tTapeDelay_setRate(tTapeDelay* const d, float rate)
495		−{
496		− d->inc = rate;
497		−}
498		−
499		−int tTapeDelay_setDelay (tTapeDelay* const d, float delay)
500		−{
501		− d->delay = LEAF_clip(1.f, delay, d->maxDelay);
502		−
503		− return 0;
504		−}
505		−
506		−float tTapeDelay_tapOut (tTapeDelay* const d, float tapDelay)
507		−{
508		− float tap = (float) d->inPoint - tapDelay - 1.f;
509		−
510		− // Check for wraparound.
511		− while ( tap < 0.f ) tap += (float)d->maxDelay;
512		−
513		− int idx = (int) tap;
514		−
515		− float alpha = tap - idx;
516		−
517		− float samp = LEAF_interpolate_hermite (d->buff[((idx - 1) + d->maxDelay) % d->maxDelay],
518		− d->buff[idx],
519		− d->buff[(idx + 1) % d->maxDelay],
520		− d->buff[(idx + 2) % d->maxDelay],
521		− alpha);
522		−
523		− return samp;
524		−
525		−}
526		−
527		−void tTapeDelay_tapIn (tTapeDelay* const d, float value, uint32_t tapDelay)
528		−{
529		− int32_t tap = d->inPoint - tapDelay - 1;
530		−
531		− // Check for wraparound.
532		− while ( tap < 0 ) tap += d->maxDelay;
533		−
534		− d->buff[tap] = value;
535		−}
536		−
537		−float tTapeDelay_addTo (tTapeDelay* const d, float value, uint32_t tapDelay)
538		−{
539		− int32_t tap = d->inPoint - tapDelay - 1;
540		−
541		− // Check for wraparound.
542		− while ( tap < 0 ) tap += d->maxDelay;
543		−
544		− return (d->buff[tap] += value);
545		−}
546		−
547		−float tTapeDelay_getDelay (tTapeDelay *d)
548		−{
549		− return d->delay;
550		−}
551		−
552		−float tTapeDelay_getLastOut (tTapeDelay* const d)
553		−{
554		− return d->lastOut;
555		−}
556		−
557		−float tTapeDelay_getLastIn (tTapeDelay* const d)
558		−{
559		− return d->lastIn;
560		−}
561		−
562		−void tTapeDelay_setGain (tTapeDelay* const d, float gain)
563		−{
564		− if (gain < 0.0f) d->gain = 0.0f;
565		− else d->gain = gain;
566		−}
567		−
568		−float tTapeDelay_getGain (tTapeDelay* const d)
569		−{
570		− return d->gain;
	434	+}
	435	+
	436	+// ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ TapeDelay ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ //
	437	+void tTapeDelay_init (tTapeDelay* const d, float delay, uint32_t maxDelay)
	438	+{
	439	+ d->maxDelay = maxDelay;
	440	+
	441	+ d->buff = (float) leaf_alloc(sizeof(float) maxDelay);
	442	+
	443	+ d->gain = 1.0f;
	444	+
	445	+ d->lastIn = 0.0f;
	446	+ d->lastOut = 0.0f;
	447	+
	448	+ d->idx = 0.0f;
	449	+ d->inc = 1.0f;
	450	+ d->inPoint = 0;
	451	+
	452	+ tTapeDelay_setDelay(d, delay);
	453	+}
	454	+
	455	+void tTapeDelay_free(tTapeDelay* const d)
	456	+{
	457	+ leaf_free(d->buff);
	458	+ leaf_free(d);
	459	+}
	460	+
	461	+//#define SMOOTH_FACTOR 10.f
	462	+
	463	+float tTapeDelay_tick (tTapeDelay* const d, float input)
	464	+{
	465	+ d->buff[d->inPoint] = input * d->gain;
	466	+
	467	+ // Increment input pointer modulo length.
	468	+ if (++(d->inPoint) == d->maxDelay ) d->inPoint = 0;
	469	+
	470	+ int idx = (int) d->idx;
	471	+ float alpha = d->idx - idx;
	472	+
	473	+ d->lastOut = LEAF_interpolate_hermite (d->buff[((idx - 1) + d->maxDelay) % d->maxDelay],
	474	+ d->buff[idx],
	475	+ d->buff[(idx + 1) % d->maxDelay],
	476	+ d->buff[(idx + 2) % d->maxDelay],
	477	+ alpha);
	478	+
	479	+ float diff = (d->inPoint - d->idx);
	480	+ while (diff < 0.f) diff += d->maxDelay;
	481	+
	482	+ d->inc = 1.0f + (diff - d->delay) / d->delay; //* SMOOTH_FACTOR;
	483	+
	484	+ d->idx += d->inc;
	485	+
	486	+ if (d->idx >= d->maxDelay) d->idx = 0.0f;
	487	+
	488	+ return d->lastOut;
	489	+}
	490	+
	491	+
	492	+void tTapeDelay_setRate(tTapeDelay* const d, float rate)
	493	+{
	494	+ d->inc = rate;
	495	+}
	496	+
	497	+int tTapeDelay_setDelay (tTapeDelay* const d, float delay)
	498	+{
	499	+ d->delay = LEAF_clip(1.f, delay, d->maxDelay);
	500	+
	501	+ return 0;
	502	+}
	503	+
	504	+float tTapeDelay_tapOut (tTapeDelay* const d, float tapDelay)
	505	+{
	506	+ float tap = (float) d->inPoint - tapDelay - 1.f;
	507	+
	508	+ // Check for wraparound.
	509	+ while ( tap < 0.f ) tap += (float)d->maxDelay;
	510	+
	511	+ int idx = (int) tap;
	512	+
	513	+ float alpha = tap - idx;
	514	+
	515	+ float samp = LEAF_interpolate_hermite (d->buff[((idx - 1) + d->maxDelay) % d->maxDelay],
	516	+ d->buff[idx],
	517	+ d->buff[(idx + 1) % d->maxDelay],
	518	+ d->buff[(idx + 2) % d->maxDelay],
	519	+ alpha);
	520	+
	521	+ return samp;
	522	+
	523	+}
	524	+
	525	+void tTapeDelay_tapIn (tTapeDelay* const d, float value, uint32_t tapDelay)
	526	+{
	527	+ int32_t tap = d->inPoint - tapDelay - 1;
	528	+
	529	+ // Check for wraparound.
	530	+ while ( tap < 0 ) tap += d->maxDelay;
	531	+
	532	+ d->buff[tap] = value;
	533	+}
	534	+
	535	+float tTapeDelay_addTo (tTapeDelay* const d, float value, uint32_t tapDelay)
	536	+{
	537	+ int32_t tap = d->inPoint - tapDelay - 1;
	538	+
	539	+ // Check for wraparound.
	540	+ while ( tap < 0 ) tap += d->maxDelay;
	541	+
	542	+ return (d->buff[tap] += value);
	543	+}
	544	+
	545	+float tTapeDelay_getDelay (tTapeDelay *d)
	546	+{
	547	+ return d->delay;
	548	+}
	549	+
	550	+float tTapeDelay_getLastOut (tTapeDelay* const d)
	551	+{
	552	+ return d->lastOut;
	553	+}
	554	+
	555	+float tTapeDelay_getLastIn (tTapeDelay* const d)
	556	+{
	557	+ return d->lastIn;
	558	+}
	559	+
	560	+void tTapeDelay_setGain (tTapeDelay* const d, float gain)
	561	+{
	562	+ if (gain < 0.0f) d->gain = 0.0f;
	563	+ else d->gain = gain;
	564	+}
	565	+
	566	+float tTapeDelay_getGain (tTapeDelay* const d)
	567	+{
	568	+ return d->gain;
571	569	}
572	570

reduced mempool size and removed variable count

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code