sigrid/leaf

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

@@ -1,6 +1,6 @@
1	/*==============================================================================	1	/*==============================================================================
2		2
3	leaf_808.h	3	leaf-808.h
4	Created: 30 Nov 2018 10:24:44am	4	Created: 30 Nov 2018 10:24:44am
5	Author: airship	5	Author: airship
6		6

LEAF/Inc/leaf-crusher.h+64−0

@@ -0,0 +1,64 @@
	1	/*
	2	==============================================================================
	3
	4	leaf-crusher.h
	5	Created: 7 Feb 2019 10:58:22am
	6	Author: airship
	7
	8	==============================================================================
	9	*/
	10
	11	#ifndef LEAF_CRUSHER_H_INCLUDED
	12	#define LEAF_CRUSHER_H_INCLUDED
	13
	14
	15	#ifdef __cplusplus
	16	extern "C" {
	17	#endif
	18
	19	//==============================================================================
	20
	21	#include "leaf-globals.h"
	22	#include "leaf-math.h"
	23
	24	//==============================================================================
	25
	26	typedef struct _tCrusher
	27	{
	28	float srr;
	29	float mult, div;
	30	float rnd;
	31
	32	uint32_t op; //which bitwise operation (0-7)
	33
	34	float gain;
	35
	36	} tCrusher;
	37
	38
	39	void tCrusher_init (tCrusher* const);
	40	void tCrusher_free (tCrusher* const);
	41
	42	float tCrusher_tick (tCrusher* const, float input);
	43
	44	// 0-7
	45	void tCrusher_setOperation (tCrusher* const, uint32_t op);
	46
	47	// 0.0 - 1.0
	48	void tCrusher_setQuality (tCrusher* const, float val);
	49
	50	// what division to round to
	51	void tCrusher_setRound (tCrusher* const, float rnd);
	52
	53	// sampling ratio
	54	void tCrusher_setSamplingRatio (tCrusher* const, float ratio);
	55
	56	//==============================================================================
	57
	58	#ifdef __cplusplus
	59	}
	60	#endif
	61
	62	#endif // LEAF_WAVEFOLDER_H_INCLUDED
	63
	64	//==============================================================================

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

@@ -1,6 +1,6 @@
1	/*==============================================================================	1	/*==============================================================================
2		2
3	LEAFDelay.h	3	leaf-delay.h
4	Created: 20 Jan 2017 12:01:24pm	4	Created: 20 Jan 2017 12:01:24pm
5	Author: Michael R Mulshine	5	Author: Michael R Mulshine
6		6

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

@@ -1,6 +1,6 @@
1	/*==============================================================================	1	/*==============================================================================
2		2
3	LEAFFilter.h	3	leaf-filter.h
4	Created: 20 Jan 2017 12:01:10pm	4	Created: 20 Jan 2017 12:01:10pm
5	Author: Michael R Mulshine	5	Author: Michael R Mulshine
6		6

LEAF/Inc/leaf-globals.h+5−0

@@ -60,6 +60,11 @@ extern const float shaper1[SHAPER1_TABLE_SIZE]; · 59 unmodified lines
60	#define TALKBOX_BUFFER_LENGTH 1600 // Every talkbox instance introduces 5 buffers of this size	60	#define TALKBOX_BUFFER_LENGTH 1600 // Every talkbox instance introduces 5 buffers of this size
61		61
62		62
		63	union unholy_t { /* a union between a float and an integer */
		64	float f;
		65	int i;
		66	};
		67
63	//==============================================================================	68	//==============================================================================
64		69
65	#ifdef __cplusplus	70	#ifdef __cplusplus

LEAF/Inc/leaf-math.h+45−41

@@ -1,22 +1,22 @@
1	/*==============================================================================	1	/*==============================================================================
2		2
3	LEAFMath.h	3	leaf-math.h
4	Created: 22 Jan 2017 7:02:56pm	4	Created: 22 Jan 2017 7:02:56pm
5	Author: Michael R Mulshine	5	Author: Michael R Mulshine
6		6
7	==============================================================================*/	7	==============================================================================*/
8		8
9	#ifndef LEAF_MATH_H_INCLUDED	9	#ifndef LEAF_MATH_H_INCLUDED
10	#define LEAF_MATH_H_INCLUDED	10	#define LEAF_MATH_H_INCLUDED
11		11
12	#ifdef __cplusplus	12	#ifdef __cplusplus
13	extern "C" {	13	extern "C" {
14	#endif	14	#endif
15		15
16	#include "math.h"	16	#include "math.h"
17	#include "stdint.h"	17	#include "stdint.h"
18	#include "stdlib.h"	18	#include "stdlib.h"
19		19
20	//==============================================================================	20	//==============================================================================
21		21
22	typedef enum oBool	22	typedef enum oBool
@@ -76,47 +76,51 @@ typedef enum oBool · 53 unmodified lines
76		76
77	// Jones shaper	77	// Jones shaper
78	float LEAF_shaper (float input, float m_drive);	78	float LEAF_shaper (float input, float m_drive);
79	float LEAF_reedTable (float input, float offset, float slope);	79	float LEAF_reedTable (float input, float offset, float slope);
		80
		81	float LEAF_reduct (float input, float srr);
		82	float LEAF_round (float input, float rnd);
		83	float LEAF_bitwise_or(float input, uint32_t op);
80		84
81	float LEAF_clip (float min, float val, float max);	85	float LEAF_clip (float min, float val, float max);
82	int LEAF_clipInt (int min, int val, int max);	86	int LEAF_clipInt (int min, int val, int max);
83	float LEAF_softClip (float val, float thresh);	87	float LEAF_softClip (float val, float thresh);
84	oBool LEAF_isPrime (uint64_t number );	88	oBool LEAF_isPrime (uint64_t number );
85		89
86	float LEAF_midiToFrequency (float f);	90	float LEAF_midiToFrequency (float f);
87	float LEAF_frequencyToMidi(float f);	91	float LEAF_frequencyToMidi(float f);
88		92
89	void LEAF_generate_sine (float* buffer, int size);	93	void LEAF_generate_sine (float* buffer, int size);
90	void LEAF_generate_sawtooth (float* buffer, float basefreq, int size);	94	void LEAF_generate_sawtooth (float* buffer, float basefreq, int size);
91	void LEAF_generate_triangle (float* buffer, float basefreq, int size);	95	void LEAF_generate_triangle (float* buffer, float basefreq, int size);
92	void LEAF_generate_square (float* buffer, float basefreq, int size);	96	void LEAF_generate_square (float* buffer, float basefreq, int size);
93		97
94	// dope af	98	// dope af
95	float LEAF_chebyshevT(float in, int n);	99	float LEAF_chebyshevT(float in, int n);
96	float LEAF_CompoundChebyshevT(float in, int n, float* amps);	100	float LEAF_CompoundChebyshevT(float in, int n, float* amps);
97
98
99	// Hermite interpolation
100	float LEAF_interpolate_hermite (float A, float B, float C, float D, float t);
101	float LEAF_interpolation_linear (float A, float B, float t);
102
103	float interpolate3max(float *buf, const int peakindex);
104	float interpolate3phase(float *buf, const int peakindex);
105
106	// alternative implementation for abs()
107	// REQUIRES: 32 bit integers
108	int fastabs_int(int in);
109
110	// alternative implementation for abs()
111	// REQUIRES: 32 bit floats
112	float fastabs(float f);
113
114	//==============================================================================
115
116	#ifdef __cplusplus
117	}
118	#endif
119		101
120	#endif // LEAF_MATH_H_INCLUDED	102
121		103	// Hermite interpolation
		104	float LEAF_interpolate_hermite (float A, float B, float C, float D, float t);
		105	float LEAF_interpolation_linear (float A, float B, float t);
		106
		107	float interpolate3max(float *buf, const int peakindex);
		108	float interpolate3phase(float *buf, const int peakindex);
		109
		110	// alternative implementation for abs()
		111	// REQUIRES: 32 bit integers
		112	int fastabs_int(int in);
		113
		114	// alternative implementation for abs()
		115	// REQUIRES: 32 bit floats
		116	float fastabs(float f);
		117
		118	//==============================================================================
		119
		120	#ifdef __cplusplus
		121	}
		122	#endif
		123
		124	#endif // LEAF_MATH_H_INCLUDED
		125
122	//==============================================================================	126	//==============================================================================

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

@@ -1,6 +1,6 @@
1	/*==============================================================================	1	/*==============================================================================
2		2
3	LEAFOscillator.h	3	leaf-oscillator.h
4	Created: 20 Jan 2017 12:00:58pm	4	Created: 20 Jan 2017 12:00:58pm
5	Author: Michael R Mulshine	5	Author: Michael R Mulshine
6		6

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

@@ -1,6 +1,6 @@
1	/*==============================================================================	1	/*==============================================================================
2		2
3	LEAFReverb.h	3	leaf-reverb.h
4	Created: 20 Jan 2017 12:02:04pm	4	Created: 20 Jan 2017 12:02:04pm
5	Author: Michael R Mulshine	5	Author: Michael R Mulshine
6		6

LEAF/Inc/leaf-sample.h+67−67

@@ -17,8 +17,8 @@ extern "C" { · 16 unmodified lines
17	//==============================================================================	17	//==============================================================================
18		18
19	#include "leaf-globals.h"	19	#include "leaf-globals.h"
20	#include "leaf-math.h"	20	#include "leaf-math.h"
21		21
22	#include "leaf-utilities.h"	22	#include "leaf-utilities.h"
23		23
24	//==============================================================================	24	//==============================================================================
@@ -34,11 +34,11 @@ extern "C" { · 9 unmodified lines
34	{	34	{
35	float* buff;	35	float* buff;
36		36
37	uint32_t idx;	37	uint32_t idx;
38	uint32_t length;	38	uint32_t length;
39		39
40	RecordMode mode;	40	RecordMode mode;
41		41
42	int active;	42	int active;
43		43
44	} tBuffer;	44	} tBuffer;
@@ -46,72 +46,72 @@ extern "C" { · 1 unmodified line
46	void tBuffer_init (tBuffer* const, uint32_t length);	46	void tBuffer_init (tBuffer* const, uint32_t length);
47	void tBuffer_free (tBuffer* const);	47	void tBuffer_free (tBuffer* const);
48		48
49	void tBuffer_tick (tBuffer* const, float sample);	49	void tBuffer_tick (tBuffer* const, float sample);
50		50
51	void tBuffer_read(tBuffer* const, float* buff, uint32_t len);	51	void tBuffer_read(tBuffer* const, float* buff, uint32_t len);
52		52
53	float tBuffer_get (tBuffer* const, int idx);	53	float tBuffer_get (tBuffer* const, int idx);
54		54
55	void tBuffer_record (tBuffer* const);	55	void tBuffer_record (tBuffer* const);
56	void tBuffer_stop (tBuffer* const);	56	void tBuffer_stop (tBuffer* const);
57		57
58	void tBuffer_setRecordMode (tBuffer* const, RecordMode mode);	58	void tBuffer_setRecordMode (tBuffer* const, RecordMode mode);
59		59
60	void tBuffer_clear (tBuffer* const);	60	void tBuffer_clear (tBuffer* const);
61		61
62	//==============================================================================	62	//==============================================================================
63		63
64	typedef enum Mode	64	typedef enum Mode
65	{	65	{
66	Normal,	66	Normal,
67	Loop,	67	Loop,
68	BackAndForth,	68	BackAndForth,
69	SampleModeNil	69	SampleModeNil
70	} Mode;	70	} Mode;
71		71
72	typedef struct _tSampler	72	typedef struct _tSampler
73	{	73	{
74	tBuffer* samp;	74	tBuffer* samp;
75		75
76	tRamp gain;	76	tRamp gain;
77		77
78	float idx;	78	float idx;
79	float inc;	79	float inc;
80	float iinc;	80	float iinc;
81	int8_t dir;	81	int8_t dir;
82	int8_t flip;	82	int8_t flip;
83	int8_t bnf;	83	int8_t bnf;
84		84
85	int32_t start;	85	int32_t start;
86	int32_t end;	86	int32_t end;
87	uint32_t len;	87	uint32_t len;
88	uint32_t cfxlen;	88	uint32_t cfxlen;
89		89
90	Mode mode;	90	Mode mode;
91	int retrigger;	91	int retrigger;
92		92
93	int active;	93	int active;
94		94
95	} tSampler;	95	} tSampler;
96		96
97	void tSampler_init (tSampler* const, tBuffer* s);	97	void tSampler_init (tSampler* const, tBuffer* s);
98	void tSampler_free (tSampler* const);	98	void tSampler_free (tSampler* const);
99		99
100	float tSampler_tick (tSampler* const);	100	float tSampler_tick (tSampler* const);
101		101
102	void tSampler_setSample (tSampler* const, tBuffer* s);	102	void tSampler_setSample (tSampler* const, tBuffer* s);
103		103
104	void tSampler_setMode (tSampler* const, Mode mode);	104	void tSampler_setMode (tSampler* const, Mode mode);
105		105
106	void tSampler_play (tSampler* const);	106	void tSampler_play (tSampler* const);
107	void tSampler_stop (tSampler* const);	107	void tSampler_stop (tSampler* const);
108		108
109	void tSampler_setStart (tSampler* const, int32_t start);	109	void tSampler_setStart (tSampler* const, int32_t start);
110	void tSampler_setEnd (tSampler* const, int32_t end);	110	void tSampler_setEnd (tSampler* const, int32_t end);
111		111
112	void tSampler_setCrossfadeLength (tSampler* const p, uint32_t length);	112	void tSampler_setCrossfadeLength (tSampler* const p, uint32_t length);
113		113
114	void tSampler_setRate (tSampler* const, float rate);	114	void tSampler_setRate (tSampler* const, float rate);
115		115
116	//==============================================================================	116	//==============================================================================
117		117

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

@@ -1,6 +1,6 @@
1	/*==============================================================================	1	/*==============================================================================
2		2
3	LEAFUtilities.h	3	leaf-utilities.h
4	Created: 20 Jan 2017 12:02:17pm	4	Created: 20 Jan 2017 12:02:17pm
5	Author: Michael R Mulshine	5	Author: Michael R Mulshine
6		6

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

@@ -1,6 +1,6 @@
1	/*==============================================================================	1	/*==============================================================================
2		2
3	LEAFInstrument.h	3	leaf-vocoder.h
4	Created: 20 Jan 2017 12:01:54pm	4	Created: 20 Jan 2017 12:01:54pm
5	Author: Michael R Mulshine	5	Author: Michael R Mulshine
6		6

LEAF/Inc/leaf-wavefolder.h+18−18

@@ -4,14 +4,14 @@ · 3 unmodified lines
4	Created: 30 Nov 2018 11:57:05am	4	Created: 30 Nov 2018 11:57:05am
5	Author: airship	5	Author: airship
6		6
7	==============================================================================*/	7	==============================================================================*/
8		8
9	#ifndef LEAF_WAVEFOLDER_H_INCLUDED	9	#ifndef LEAF_WAVEFOLDER_H_INCLUDED
10	#define LEAF_WAVEFOLDER_H_INCLUDED	10	#define LEAF_WAVEFOLDER_H_INCLUDED
11		11
12		12
13	#ifdef __cplusplus	13	#ifdef __cplusplus
14	extern "C" {	14	extern "C" {
15	#endif	15	#endif
16		16
17	//==============================================================================	17	//==============================================================================
@@ -45,14 +45,14 @@ void tLockhartWavefolder_init (tLockhartWavefolder* const); · 27 unmodified lines
45	void tLockhartWavefolder_free (tLockhartWavefolder* const);	45	void tLockhartWavefolder_free (tLockhartWavefolder* const);
46		46
47	float tLockhartWavefolder_tick (tLockhartWavefolder* const, float samp);	47	float tLockhartWavefolder_tick (tLockhartWavefolder* const, float samp);
48		48
49		49
50	//==============================================================================	50	//==============================================================================
51		51
52	#ifdef __cplusplus	52	#ifdef __cplusplus
53	}	53	}
54	#endif	54	#endif
55		55
56	#endif // LEAF_WAVEFOLDER_H_INCLUDED	56	#endif // LEAF_WAVEFOLDER_H_INCLUDED
57		57
58	//==============================================================================	58	//==============================================================================

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

@@ -1,6 +1,6 @@
1	/*==============================================================================	1	/*==============================================================================
2		2
3	LEAFWavetables.h	3	leaf-wavetables.h
4	Created: 4 Dec 2016 9:42:41pm	4	Created: 4 Dec 2016 9:42:41pm
5	Author: Michael R Mulshine	5	Author: Michael R Mulshine
6		6

LEAF/Src/leaf-808.c+3−5

-/*
+/*==============================================================================
-  ==============================================================================
-    leaf_808.cpp
+    leaf-808.c
     Created: 30 Nov 2018 10:24:21am
     Author:  airship
-  ==============================================================================
+==============================================================================*/
-*/
 #if _WIN32 || _WIN64

LEAF/Src/leaf-crusher.c+84−0

@@ -0,0 +1,84 @@
	1	/*==============================================================================
	2
	3	leaf-crusher.c
	4	Created: 30 Nov 2018 11:56:49am
	5	Author: airship
	6
	7	==============================================================================*/
	8
	9	#if _WIN32 \|\| _WIN64
	10
	11	#include "..\Inc\leaf-crusher.h"
	12
	13	#else
	14
	15	#include "../Inc/leaf-crusher.h"
	16
	17	#endif
	18
	19	//==============================================================================
	20
	21	#define SCALAR 5000.f
	22
	23	void tCrusher_init (tCrusher* const c)
	24	{
	25	c->op = 4;
	26	c->div = SCALAR;
	27	c->rnd = 0.25f;
	28	c->srr = 0.25f;
	29
	30	c->gain = (c->div / SCALAR) * 0.7f + 0.3f;
	31	}
	32
	33	void tCrusher_free (tCrusher* const c)
	34	{
	35	leaf_free(c);
	36	}
	37
	38	float tCrusher_tick (tCrusher* const c, float input)
	39	{
	40	float sample = input;
	41
	42	sample *= SCALAR; // SCALAR is 5000 by default
	43
	44	sample = floorf(sample);
	45
	46	sample /= c->div;
	47
	48	sample = LEAF_bitwise_or(sample, c->op << 23);
	49
	50	sample = LEAF_clip(-1.f, sample, 1.f);
	51
	52	sample = LEAF_round(sample, c->rnd);
	53
	54	sample = LEAF_reduct(sample, c->srr);
	55
	56	return sample * c->gain;
	57
	58	}
	59
	60	void tCrusher_setOperation (tCrusher* const c, uint32_t op)
	61	{
	62	c->op = op % 8;
	63	}
	64
	65	// 0.0 - 1.0
	66	void tCrusher_setQuality (tCrusher* const c, float val)
	67	{
	68	val = LEAF_clip(0.0f, val, 1.0f);
	69
	70	c->div = 0.01f + val * SCALAR;
	71
	72	c->gain = (c->div / SCALAR) * 0.7f + 0.3f;
	73	}
	74
	75	// what decimal to round to
	76	void tCrusher_setRound (tCrusher* const c, float rnd)
	77	{
	78	c->rnd = fabsf(rnd);
	79	}
	80
	81	void tCrusher_setSamplingRatio (tCrusher* const c, float ratio)
	82	{
	83	c->srr = ratio;
	84	}

LEAF/Src/leaf-delay.c+3−5

-/*
+/*==============================================================================
-  ==============================================================================
-    LEAFDelay.c
+    leaf-delay.c
     Created: 20 Jan 2017 12:01:24pm
     Author:  Michael R Mulshine
-  ==============================================================================
+==============================================================================*/
-*/
 #if _WIN32 || _WIN64

LEAF/Src/leaf-filter.c+3−5

-/*
+/*==============================================================================
-  ==============================================================================
-    LEAFFilter.c
+    leaf-filter.c
     Created: 20 Jan 2017 12:01:10pm
     Author:  Michael R Mulshine
-  ==============================================================================
+==============================================================================*/
-*/
 #if _WIN32 || _WIN64

LEAF/Src/leaf-formant.c+3−5

-/*
+/*==============================================================================
-  ==============================================================================
-    leaf-formant.cpp
+    leaf-formant.c
     Created: 30 Nov 2018 11:03:30am
     Author:  airship
-  ==============================================================================
+==============================================================================*/
-*/
 #if _WIN32 || _WIN64

LEAF/Src/leaf-math.c+48−6

@@ -1,12 +1,10 @@
1	/*	1	/*==============================================================================
2	==============================================================================
3		2
4	LEAFMath.c	3	leaf-math.c
5	Created: 22 Jan 2017 7:02:56pm	4	Created: 22 Jan 2017 7:02:56pm
6	Author: Michael R Mulshine	5	Author: Michael R Mulshine
7		6
8	==============================================================================	7	==============================================================================*/
9	*/
10		8
11	#if _WIN32 \|\| _WIN64	9	#if _WIN32 \|\| _WIN64
12		10
@@ -24,7 +22,7 @@ · 11 unmodified lines
24	#define TWO_TO_16 65536.f	22	#define TWO_TO_16 65536.f
25		23
26	#define EXPONENTIAL_TABLE_SIZE 65536	24	#define EXPONENTIAL_TABLE_SIZE 65536
27		25
28		26
29	float interpolate3max(float *buf, const int peakindex)	27	float interpolate3max(float *buf, const int peakindex)
30	{	28	{
@@ -119,6 +117,50 @@ float LEAF_shaper(float input, float m_drive) · 88 unmodified lines
119	float shaperOut = w(c+ 0.05fxc2)*(m_drive + 0.75f);	117	float shaperOut = w(c+ 0.05fxc2)*(m_drive + 0.75f);
120	shaperOut *= 0.5f; // post_scale	118	shaperOut *= 0.5f; // post_scale
121	return shaperOut;	119	return shaperOut;
		120	}
		121
		122	// reduce sample resolution
		123	float LEAF_reduct (float input, float sr)
		124	{
		125	float samp = input;
		126
		127	samp *= sr;
		128
		129	// method 1
		130	samp = ceilf(samp);
		131
		132	samp /= sr;
		133
		134	/*
		135	// method 2
		136	samp = floorf(samp + 0.5f) - 0.5f;
		137
		138	samp /= srr;
		139	*/
		140
		141	return samp;
		142	}
		143
		144	// round input to nearest rnd
		145	float LEAF_round (float input, float rnd)
		146	{
		147	rnd = fabsf(rnd);
		148
		149	if (rnd <= 0.0000001f) return input;
		150
		151	float scale = 1.f / rnd;
		152
		153	return roundf(input * scale) / scale;
		154	}
		155
		156	union unholy_t unholy;
		157
		158	float LEAF_bitwise_or(float input, uint32_t op)
		159	{
		160	unholy.f = input;
		161	unholy.i = (unholy.i \| op);
		162
		163	return unholy.f;
122	}	164	}
123		165
124	float LEAF_reedTable(float input, float offset, float slope)	166	float LEAF_reedTable(float input, float offset, float slope)

LEAF/Src/leaf-midi.c+3−5

-/*
+/*==============================================================================
-  ==============================================================================
-    leaf-midi.cpp
+    leaf-midi.c
     Created: 30 Nov 2018 11:29:16am
     Author:  airship
-  ==============================================================================
+==============================================================================*/
-*/
 #if _WIN32 || _WIN64

LEAF/Src/leaf-oscillator.c+3−5

-/*
+/*==============================================================================
-  ==============================================================================
-    LEAFOscillator.c
+    leaf-oscillator.c
     Created: 20 Jan 2017 12:00:58pm
     Author:  Michael R Mulshine
-  ==============================================================================
+==============================================================================*/
-*/
 #if _WIN32 || _WIN64

LEAF/Src/leaf-pitch.c+3−5

-/*
+/*==============================================================================
-  ==============================================================================
-    leaf-pitch.cpp
+    leaf-pitch.c
     Created: 30 Nov 2018 11:02:59am
     Author:  airship
-  ==============================================================================
+==============================================================================*/
-*/
 #if _WIN32 || _WIN64

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

-/*
+/*==============================================================================
-  ==============================================================================
-    LEAFReverb.c
+    leaf-reverb.c
     Created: 20 Jan 2017 12:02:04pm
     Author:  Michael R Mulshine
-  ==============================================================================
+==============================================================================*/
-*/
 #if _WIN32 || _WIN64

LEAF/Src/leaf-sample.c+406−406

@@ -1,7 +1,7 @@
1	/*	1	/*
2	==============================================================================	2	==============================================================================
3		3
4	LEAFUtilities.c	4	leaf-sample.c
5	Created: 20 Jan 2017 12:02:17pm	5	Created: 20 Jan 2017 12:02:17pm
6	Author: Michael R Mulshine	6	Author: Michael R Mulshine
7		7
@@ -10,7 +10,7 @@ · 2 unmodified lines
10		10
11		11
12	#if _WIN32 \|\| _WIN64	12	#if _WIN32 \|\| _WIN64
13		13
14	#include "..\Inc\leaf-sample.h"	14	#include "..\Inc\leaf-sample.h"
15	#include "..\leaf.h"	15	#include "..\leaf.h"
16		16
@@ -19,412 +19,412 @@ · 2 unmodified lines
19	#include "../Inc/leaf-sample.h"	19	#include "../Inc/leaf-sample.h"
20	#include "../leaf.h"	20	#include "../leaf.h"
21		21
22	#endif	22	#endif
23		23
24	//==============================================================================	24	//==============================================================================
25		25
26	void tBuffer_init (tBuffer* const s, uint32_t length)	26	void tBuffer_init (tBuffer* const s, uint32_t length)
27	{	27	{
28	s->buff = (float) leaf_alloc( sizeof(float) length);	28	s->buff = (float) leaf_alloc( sizeof(float) length);
29		29
30		30
31	s->length = length;	31	s->length = length;
32	s->active = 0;	32	s->active = 0;
33	s->idx = 0;	33	s->idx = 0;
34	s->mode = RecordOneShot;	34	s->mode = RecordOneShot;
35		35
36	tBuffer_clear(s);	36	tBuffer_clear(s);
37	}	37	}
38		38
39	void tBuffer_free (tBuffer* const s)	39	void tBuffer_free (tBuffer* const s)
40	{	40	{
41	leaf_free(s->buff);	41	leaf_free(s->buff);
42	leaf_free(s);	42	leaf_free(s);
43	}	43	}
44		44
45	void tBuffer_tick (tBuffer* const s, float sample)	45	void tBuffer_tick (tBuffer* const s, float sample)
46	{	46	{
47	if (s->active == 1)	47	if (s->active == 1)
48	{	48	{
49	s->buff[s->idx] = sample;	49	s->buff[s->idx] = sample;
50		50
51	s->idx += 1;	51	s->idx += 1;
52		52
53	if (s->idx >= s->length)	53	if (s->idx >= s->length)
54	{	54	{
55	if (s->mode == RecordOneShot)	55	if (s->mode == RecordOneShot)
56	{	56	{
57	tBuffer_stop(s);	57	tBuffer_stop(s);
58	}	58	}
59	else if (s->mode == RecordLoop)	59	else if (s->mode == RecordLoop)
60	{	60	{
61	s->idx = 0;	61	s->idx = 0;
62	}	62	}
63	}	63	}
64	}	64	}
65	}	65	}
66		66
67	void tBuffer_read(tBuffer* const s, float* buff, uint32_t len)	67	void tBuffer_read(tBuffer* const s, float* buff, uint32_t len)
68	{	68	{
69	for (int i = 0; i < s->length; i++)	69	for (int i = 0; i < s->length; i++)
70	{	70	{
71	if (i < len) s->buff[i] = buff[i];	71	if (i < len) s->buff[i] = buff[i];
72	else s->buff[i] = 0.f;	72	else s->buff[i] = 0.f;
73	}	73	}
74	}	74	}
75		75
76	float tBuffer_get (tBuffer* const s, int idx)	76	float tBuffer_get (tBuffer* const s, int idx)
77	{	77	{
78	if ((idx < 0) \|\| (idx >= s->length)) return 0.f;	78	if ((idx < 0) \|\| (idx >= s->length)) return 0.f;
79		79
80	return s->buff[idx];	80	return s->buff[idx];
81	}	81	}
82		82
83	void tBuffer_record(tBuffer* const s)	83	void tBuffer_record(tBuffer* const s)
84	{	84	{
85	s->active = 1;	85	s->active = 1;
86	s->idx = 0;	86	s->idx = 0;
87	}	87	}
88		88
89	void tBuffer_stop(tBuffer* const s)	89	void tBuffer_stop(tBuffer* const s)
90	{	90	{
91	s->active = 0;	91	s->active = 0;
92	}	92	}
93		93
94	void tBuffer_setRecordMode (tBuffer* const s, RecordMode mode)	94	void tBuffer_setRecordMode (tBuffer* const s, RecordMode mode)
95	{	95	{
96	s->mode = mode;	96	s->mode = mode;
97	}	97	}
98		98
99	void tBuffer_clear (tBuffer* const s)	99	void tBuffer_clear (tBuffer* const s)
100	{	100	{
101	for (int i = 0; i < s->length; i++)	101	for (int i = 0; i < s->length; i++)
102	{	102	{
103	s->buff[i] = 0.f;	103	s->buff[i] = 0.f;
104	}	104	}
105	}	105	}
106		106
107	//================================tSampler=====================================	107	//================================tSampler=====================================
108		108
109	void tSampler_init (tSampler* const p, tBuffer* s)	109	void tSampler_init (tSampler* const p, tBuffer* s)
110	{	110	{
111	p->samp = s;	111	p->samp = s;
112		112
113	p->active = 0;	113	p->active = 0;
114		114
115	p->start = 0;	115	p->start = 0;
116	p->end = p->samp->length - 1;	116	p->end = p->samp->length - 1;
117		117
118	p->len = p->end - p->start;	118	p->len = p->end - p->start;
119		119
120	p->idx = 0.f;	120	p->idx = 0.f;
121	p->inc = 1.f;	121	p->inc = 1.f;
122	p->iinc = 1.f;	122	p->iinc = 1.f;
123		123
124	p->dir = 1;	124	p->dir = 1;
125	p->flip = 1;	125	p->flip = 1;
126	p->bnf = 1;	126	p->bnf = 1;
127		127
128	p->mode = Normal;	128	p->mode = Normal;
129		129
130	p->cfxlen = 300; // default 300 sample crossfade	130	p->cfxlen = 300; // default 300 sample crossfade
131		131
132	tRamp_init(&p->gain, 7.0f, 1);	132	tRamp_init(&p->gain, 7.0f, 1);
133	tRamp_setVal(&p->gain, 0.f);	133	tRamp_setVal(&p->gain, 0.f);
134	}	134	}
135		135
136	void tSampler_free (tSampler* const p)	136	void tSampler_free (tSampler* const p)
137	{	137	{
138	leaf_free(p->samp);	138	leaf_free(p->samp);
139	leaf_free(p);	139	leaf_free(p);
140	}	140	}
141		141
142	float tSampler_tick (tSampler* const p)	142	float tSampler_tick (tSampler* const p)
143	{	143	{
144	if (p->active == 0 \|\| (p->len < 4)) return 0.f;	144	if (p->active == 0 \|\| (p->len < 4)) return 0.f;
145		145
146	float sample = 0.f;	146	float sample = 0.f;
147	float cfxsample = 0.f;	147	float cfxsample = 0.f;
148	int numsamps;	148	int numsamps;
149	float g1 = 1.f, g2 = 0.f;	149	float g1 = 1.f, g2 = 0.f;
150		150
151	float* buff = p->samp->buff;	151	float* buff = p->samp->buff;
152		152
153	int dir = p->bnf * p->dir * p->flip;	153	int dir = p->bnf * p->dir * p->flip;
154		154
155	int idx;	155	int idx;
156	float alpha;	156	float alpha;
157		157
158	if (dir > 0)	158	if (dir > 0)
159	{	159	{
160	idx = (int) p->idx;	160	idx = (int) p->idx;
161	alpha = p->idx - idx;	161	alpha = p->idx - idx;
162	}	162	}
163	else	163	else
164	{	164	{
165	idx = (int) (p->idx + 1.f); // we think this is because flooring on int works different when reading backwards	165	idx = (int) (p->idx + 1.f); // we think this is because flooring on int works different when reading backwards
166	alpha = (p->idx+1.f) - idx;	166	alpha = (p->idx+1.f) - idx;
167	}	167	}
168		168
169	int32_t start = p->start, end = p->end;	169	int32_t start = p->start, end = p->end;
170	if (p->flip < 0)	170	if (p->flip < 0)
171	{	171	{
172	start = p->end;	172	start = p->end;
173	end = p->start;	173	end = p->start;
174	}	174	}
175		175
176	// Check dir (direction) to interpolate properly	176	// Check dir (direction) to interpolate properly
177	if (dir > 0)	177	if (dir > 0)
178	{	178	{
179	// FORWARD NORMAL SAMPLE	179	// FORWARD NORMAL SAMPLE
180	int i1 = idx-1;	180	int i1 = idx-1;
181	int i3 = idx+1;	181	int i3 = idx+1;
182	int i4 = idx+2;	182	int i4 = idx+2;
183		183
184	sample = LEAF_interpolate_hermite (buff[i1],	184	sample = LEAF_interpolate_hermite (buff[i1],
185	buff[idx],	185	buff[idx],
186	buff[i3],	186	buff[i3],
187	buff[i4],	187	buff[i4],
188	alpha);	188	alpha);
189		189
190	// num samples to end of loop	190	// num samples to end of loop
191	numsamps = (dir > 0) ? (end - idx) : (idx - start);	191	numsamps = (dir > 0) ? (end - idx) : (idx - start);
192	numsamps *= p->iinc;	192	numsamps *= p->iinc;
193		193
194	if (p->mode == Loop)	194	if (p->mode == Loop)
195	{	195	{
196	if (numsamps <= p->cfxlen)	196	if (numsamps <= p->cfxlen)
197	{	197	{
198	// CROSSFADE SAMPLE	198	// CROSSFADE SAMPLE
199	float idxx = p->idx - p->len;	199	float idxx = p->idx - p->len;
200	int cdx = (int)(idxx);	200	int cdx = (int)(idxx);
201		201
202	i1 = cdx-1;	202	i1 = cdx-1;
203	i3 = cdx+1;	203	i3 = cdx+1;
204	i4 = cdx+2;	204	i4 = cdx+2;
205		205
206	cfxsample = LEAF_interpolate_hermite (buff[i1],	206	cfxsample = LEAF_interpolate_hermite (buff[i1],
207	buff[cdx],	207	buff[cdx],
208	buff[i3],	208	buff[i3],
209	buff[i4],	209	buff[i4],
210	alpha);	210	alpha);
211		211
212	g2 = (float) (p->cfxlen - numsamps) / (float) p->cfxlen;	212	g2 = (float) (p->cfxlen - numsamps) / (float) p->cfxlen;
213	}	213	}
214	}	214	}
215	}	215	}
216	else	216	else
217	{	217	{
218	// REVERSE	218	// REVERSE
219	int i1 = idx+1;	219	int i1 = idx+1;
220	int i3 = idx-1;	220	int i3 = idx-1;
221	int i4 = idx-2;	221	int i4 = idx-2;
222		222
223	sample = LEAF_interpolate_hermite (buff[i1],	223	sample = LEAF_interpolate_hermite (buff[i1],
224	buff[idx],	224	buff[idx],
225	buff[i3],	225	buff[i3],
226	buff[i4],	226	buff[i4],
227	1.0f-alpha);	227	1.0f-alpha);
228		228
229	numsamps = (idx - start) / p->inc;	229	numsamps = (idx - start) / p->inc;
230		230
231	if (p->mode == Loop)	231	if (p->mode == Loop)
232	{	232	{
233	if (numsamps <= p->cfxlen)	233	if (numsamps <= p->cfxlen)
234	{	234	{
235	// CROSSFADE SAMPLE	235	// CROSSFADE SAMPLE
236	float idxx = p->idx + p->len + 1.f;	236	float idxx = p->idx + p->len + 1.f;
237	int cdx = (int)(idxx);	237	int cdx = (int)(idxx);
238	alpha = idxx - cdx;	238	alpha = idxx - cdx;
239		239
240	i1 = cdx+1;	240	i1 = cdx+1;
241	i3 = cdx-1;	241	i3 = cdx-1;
242	i4 = cdx-2;	242	i4 = cdx-2;
243		243
244	cfxsample = LEAF_interpolate_hermite (buff[i1],	244	cfxsample = LEAF_interpolate_hermite (buff[i1],
245	buff[cdx],	245	buff[cdx],
246	buff[i3],	246	buff[i3],
247	buff[i4],	247	buff[i4],
248	1.f-alpha);	248	1.f-alpha);
249		249
250	g2 = (float) (p->cfxlen - numsamps) / (float) p->cfxlen;	250	g2 = (float) (p->cfxlen - numsamps) / (float) p->cfxlen;
251	}	251	}
252	}	252	}
253	}	253	}
254		254
255	p->idx += (dir * p->inc);	255	p->idx += (dir * p->inc);
256		256
257	if (p->mode == Normal)	257	if (p->mode == Normal)
258	{	258	{
259	if (numsamps < (0.007f * leaf.sampleRate))	259	if (numsamps < (0.007f * leaf.sampleRate))
260	{	260	{
261	tRamp_setDest(&p->gain, 0.f);	261	tRamp_setDest(&p->gain, 0.f);
262	p->active = -1;	262	p->active = -1;
263	}	263	}
264	}	264	}
265	else if (p->mode == Loop ) // == Normal or Loop	265	else if (p->mode == Loop ) // == Normal or Loop
266	{	266	{
267	if (idx <= start)	267	if (idx <= start)
268	{	268	{
269	p->idx += (float)(p->len);	269	p->idx += (float)(p->len);
270	}	270	}
271	else if (idx >= end)	271	else if (idx >= end)
272	{	272	{
273	p->idx -= (float)(p->len);	273	p->idx -= (float)(p->len);
274	}	274	}
275	}	275	}
276	else // == BackAndForth	276	else // == BackAndForth
277	{	277	{
278	if (p->idx < start)	278	if (p->idx < start)
279	{	279	{
280	p->bnf = -p->bnf;	280	p->bnf = -p->bnf;
281	p->idx = start;	281	p->idx = start;
282	}	282	}
283	else if (p->idx > end)	283	else if (p->idx > end)
284	{	284	{
285	p->bnf = -p->bnf;	285	p->bnf = -p->bnf;
286	p->idx = end;	286	p->idx = end;
287	}	287	}
288	}	288	}
289		289
290	g1 = 1.f - g2;	290	g1 = 1.f - g2;
291		291
292	sample = sample * g1 + cfxsample * g2;	292	sample = sample * g1 + cfxsample * g2;
293		293
294	sample = sample * tRamp_tick(&p->gain);	294	sample = sample * tRamp_tick(&p->gain);
295		295
296	if (p->active < 0)	296	if (p->active < 0)
297	{	297	{
298	if (tRamp_sample(&p->gain) <= 0.00001f)	298	if (tRamp_sample(&p->gain) <= 0.00001f)
299	{	299	{
300	if (p->retrigger == 1)	300	if (p->retrigger == 1)
301	{	301	{
302	p->active = 1;	302	p->active = 1;
303	p->retrigger = 0;	303	p->retrigger = 0;
304	tRamp_setDest(&p->gain, 1.f);	304	tRamp_setDest(&p->gain, 1.f);
305		305
306	if (p->dir > 0)	306	if (p->dir > 0)
307	{	307	{
308	if (p->flip > 0) p->idx = p->start;	308	if (p->flip > 0) p->idx = p->start;
309	else p->idx = p->end;	309	else p->idx = p->end;
310	}	310	}
311	else	311	else
312	{	312	{
313	if (p->flip > 0) p->idx = p->end;	313	if (p->flip > 0) p->idx = p->end;
314	else p->idx = p->start;	314	else p->idx = p->start;
315	}	315	}
316	}	316	}
317	else	317	else
318	{	318	{
319	p->active = 0;	319	p->active = 0;
320	}	320	}
321		321
322	}	322	}
323	}	323	}
324		324
325	return sample;	325	return sample;
326	}	326	}
327		327
328	void tSampler_setSample (tSampler* const p, tBuffer* s)	328	void tSampler_setSample (tSampler* const p, tBuffer* s)
329	{	329	{
330	p->samp = s;	330	p->samp = s;
331	}	331	}
332		332
333	void tSampler_setMode (tSampler* const p, Mode mode)	333	void tSampler_setMode (tSampler* const p, Mode mode)
334	{	334	{
335	p->mode = mode;	335	p->mode = mode;
336	}	336	}
337		337
338	void tSampler_setCrossfadeLength (tSampler* const p, uint32_t length)	338	void tSampler_setCrossfadeLength (tSampler* const p, uint32_t length)
339	{	339	{
340	uint32_t cfxlen = LEAF_clip(0, length, 1000);	340	uint32_t cfxlen = LEAF_clip(0, length, 1000);
341		341
342	//if (cfxlen > p->len) cfxlen = p->len * 0.25f;	342	//if (cfxlen > p->len) cfxlen = p->len * 0.25f;
343		343
344	p->cfxlen = cfxlen;	344	p->cfxlen = cfxlen;
345	}	345	}
346		346
347	void tSampler_play (tSampler* const p)	347	void tSampler_play (tSampler* const p)
348	{	348	{
349	if (p->active != 0)	349	if (p->active != 0)
350	{	350	{
351	p->active = -1;	351	p->active = -1;
352	p->retrigger = 1;	352	p->retrigger = 1;
353		353
354	tRamp_setDest(&p->gain, 0.f);	354	tRamp_setDest(&p->gain, 0.f);
355	}	355	}
356	else	356	else
357	{	357	{
358	p->active = 1;	358	p->active = 1;
359	p->retrigger = 0;	359	p->retrigger = 0;
360		360
361	tRamp_setDest(&p->gain, 1.f);	361	tRamp_setDest(&p->gain, 1.f);
362		362
363	if (p->dir > 0)	363	if (p->dir > 0)
364	{	364	{
365	if (p->flip > 0) p->idx = p->start;	365	if (p->flip > 0) p->idx = p->start;
366	else p->idx = p->end;	366	else p->idx = p->end;
367	}	367	}
368	else	368	else
369	{	369	{
370	if (p->flip > 0) p->idx = p->end;	370	if (p->flip > 0) p->idx = p->end;
371	else p->idx = p->start;	371	else p->idx = p->start;
372	}	372	}
373	}	373	}
374	}	374	}
375		375
376	void tSampler_stop (tSampler* const p)	376	void tSampler_stop (tSampler* const p)
377	{	377	{
378	p->active = -1;	378	p->active = -1;
379		379
380	tRamp_setDest(&p->gain, 0.f);	380	tRamp_setDest(&p->gain, 0.f);
381	}	381	}
382		382
383	static void handleStartEndChange(tSampler* const p)	383	static void handleStartEndChange(tSampler* const p)
384	{	384	{
385	p->len = abs(p->end - p->start);	385	p->len = abs(p->end - p->start);
386		386
387	//if (p->len < p->cfxlen) p->cfxlen = p->len * 0.9f;	387	//if (p->len < p->cfxlen) p->cfxlen = p->len * 0.9f;
388		388
389	if (p->start > p->end)	389	if (p->start > p->end)
390	{	390	{
391	p->flip = -1;	391	p->flip = -1;
392	}	392	}
393	else	393	else
394	{	394	{
395	p->flip = 1;	395	p->flip = 1;
396	}	396	}
397	}	397	}
398		398
399	void tSampler_setStart (tSampler* const p, int32_t start)	399	void tSampler_setStart (tSampler* const p, int32_t start)
400	{	400	{
401	p->start = LEAF_clipInt(0, start, (p->samp->length - 1));	401	p->start = LEAF_clipInt(0, start, (p->samp->length - 1));
402		402
403	handleStartEndChange(p);	403	handleStartEndChange(p);
404	}	404	}
405		405
406	void tSampler_setEnd (tSampler* const p, int32_t end)	406	void tSampler_setEnd (tSampler* const p, int32_t end)
407	{	407	{
408	p->end = LEAF_clipInt(0, end, (p->samp->length - 1));	408	p->end = LEAF_clipInt(0, end, (p->samp->length - 1));
409		409
410	handleStartEndChange(p);	410	handleStartEndChange(p);
411	}	411	}
412		412
413	void tSampler_setRate (tSampler* const p, float rate)	413	void tSampler_setRate (tSampler* const p, float rate)
414	{	414	{
415	if (rate < 0.f)	415	if (rate < 0.f)
416	{	416	{
417	rate = -rate;	417	rate = -rate;
418	p->dir = -1;	418	p->dir = -1;
419	}	419	}
420	else	420	else
421	{	421	{
422	p->dir = 1;	422	p->dir = 1;
423	}	423	}
424		424
425	p->inc = LEAF_clip(0.f, rate, 8.0f);	425	p->inc = LEAF_clip(0.f, rate, 8.0f);
426	p->iinc = 1.f / p->inc;	426	p->iinc = 1.f / p->inc;
427	}	427	}
428		428
429		429
430	//==============================================================================	430	//==============================================================================

LEAF/Src/leaf-string.c+3−5

-/*
+/*==============================================================================
-  ==============================================================================
-    leaf-string.cpp
+    leaf-string.c
     Created: 30 Nov 2018 10:41:42am
     Author:  airship
-  ==============================================================================
+==============================================================================*/
-*/
 #if _WIN32 || _WIN64

LEAF/Src/leaf-utilities.c+3−5

-/*
+/*==============================================================================
-  ==============================================================================
-    LEAFUtilities.c
+    leaf-utilities.c
     Created: 20 Jan 2017 12:02:17pm
     Author:  Michael R Mulshine
-  ==============================================================================
+==============================================================================*/
-*/
 #if _WIN32 || _WIN64

LEAF/Src/leaf-vocoder.c+3−5

-/*
+/*==============================================================================
-  ==============================================================================
-    LEAFInstrument.c
+    leaf-vocoder.c
     Created: 20 Jan 2017 12:01:54pm
     Author:  Michael R Mulshine
-  ==============================================================================
+==============================================================================*/
-*/
 #if _WIN32 || _WIN64

LEAF/Src/leaf-wavefolder.c+3−5

-/*
+/*==============================================================================
-  ==============================================================================
-    leaf-wavefolder.cpp
+    leaf-wavefolder.c
     Created: 30 Nov 2018 11:56:49am
     Author:  airship
-  ==============================================================================
+==============================================================================*/
-*/
 #if _WIN32 || _WIN64

LEAF/leaf.h+4−2

 #include ".\Inc\leaf-pitch.h"
 #include ".\Inc\leaf-formant.h"
 #include ".\Inc\leaf-midi.h"
 #include ".\Inc\leaf-sample.h"
+#include ".\Inc\leaf-crusher.h"
 #include ".\Inc\leaf-wavefolder.h"
 #include ".\Inc\leaf-wavetables.h"
 #include "./Inc/leaf-pitch.h"
 #include "./Inc/leaf-formant.h"
 #include "./Inc/leaf-midi.h"
 #include "./Inc/leaf-sample.h"
+#include "./Inc/leaf-crusher.h"
 #include "./Inc/leaf-wavefolder.h"
 #include "./Inc/leaf-wavetables.h"

LEAF_JUCEPlugin/LEAF.jucer+2−0

                 file="../LEAF/Inc/leaf-utilities.h"/>
           <FILE id="Szb5LP" name="leaf-vocoder.h" compile="0" resource="0" file="../LEAF/Inc/leaf-vocoder.h"/>
           <FILE id="T6KXi7" name="leaf-sample.h" compile="0" resource="0" file="../LEAF/Inc/leaf-sample.h"/>
+          <FILE id="bpUZCA" name="leaf-crusher.h" compile="0" resource="0" file="../LEAF/Inc/leaf-crusher.h"/>
           <FILE id="PRkOp2" name="leaf-wavefolder.h" compile="0" resource="0"
                 file="../LEAF/Inc/leaf-wavefolder.h"/>
           <FILE id="KpGzKv" name="leaf-wavetables.h" compile="0" resource="0"
                 file="../LEAF/Src/leaf-utilities.c"/>
           <FILE id="u1aLLR" name="leaf-vocoder.c" compile="1" resource="0" file="../LEAF/Src/leaf-vocoder.c"/>
           <FILE id="nmtoFJ" name="leaf-sample.c" compile="1" resource="0" file="../LEAF/Src/leaf-sample.c"/>
+          <FILE id="Oymcac" name="leaf-crusher.c" compile="1" resource="0" file="../LEAF/Src/leaf-crusher.c"/>
           <FILE id="LVoaGm" name="leaf-wavefolder.c" compile="1" resource="0"
                 file="../LEAF/Src/leaf-wavefolder.c"/>
           <FILE id="HRk07h" name="leaf-wavetables.c" compile="1" resource="0"

LEAF_JUCEPlugin/Source/LEAFLink.cpp+6−6

@@ -15,16 +15,16 @@ · 14 unmodified lines
15		15
16	std::vector<juce::String> cButtonNames = std::vector<juce::String>	16	std::vector<juce::String> cButtonNames = std::vector<juce::String>
17	{	17	{
18	"sample",	18
19	"play"
20	};	19	};
21		20
22	std::vector<juce::String> cSliderNames = std::vector<juce::String>	21	std::vector<juce::String> cSliderNames = std::vector<juce::String>
23	{	22	{
24	"rate",	23	"sr",
25	"start",	24	"rnd",
26	"end",	25	"qual",
27	"cfxlen"	26	"op",
		27	"mix"
28	};	28	};
29		29
30	std::vector<juce::String> cComboBoxNames = std::vector<juce::String>	30	std::vector<juce::String> cComboBoxNames = std::vector<juce::String>

LEAF_JUCEPlugin/Source/MyTest.cpp+47−48

 static void leaf_pool_report(void);
 static void leaf_pool_dump(void);
 static void run_pool_test(void);
-tBuffer sample;
+float mix = 0.f;
+float fx = 1.f;
-tSampler player;
+tCrusher crusher;
 void    LEAFTest_init            (float sampleRate, int blockSize)
 {
     LEAF_init(sampleRate, blockSize, &randomNumberGenerator);
-    tBuffer_init(&sample, leaf.sampleRate * 2);
+    tCrusher_init(&crusher);
-    tSampler_init(&player, &sample);
+    leaf_pool_report();
-    tSampler_setMode(&player, Normal);
-    leaf_pool_report();
-    tBuffer_record(&sample);
 }
 int timer = 0;
 float   LEAFTest_tick            (float input)
 {
-    tBuffer_tick(&sample, input);
+    float sample = 0.f;
-    return tSampler_tick(&player);
+    sample = (mix * tCrusher_tick(&crusher, input)) + ((1.f - mix) * input);
+    return sample;
 }
 bool lastState = false, lastPlayState = false;
 void    LEAFTest_block           (void)
 {
-    float val = getSliderValue("rate");
+    float val = getSliderValue("mix");
+    mix = val;
+    val = getSliderValue("sr");
+    tCrusher_setSamplingRatio(&crusher, val * 3.99f + 0.01f);
-    float rate = val * 16.0f - 8.0f;
+    val = getSliderValue("rnd");
-    tSampler_setRate(&player, rate);
-    //DBG("rate: " + String(rate));
-    val = getSliderValue("start");
+    tCrusher_setRound(&crusher, val);
-    float start = val * sample.length;
-    tSampler_setStart(&player,  start);
-    //DBG("start: " + String(start));
-    val = getSliderValue("end");
+    val = getSliderValue("qual");
-    float end = val * sample.length;
-    tSampler_setEnd(&player, end);
-    //DBG("end: " + String(end));
-    val = getSliderValue("cfxlen");
+    tCrusher_setQuality(&crusher, val);
-    uint32_t cfxlen = val * 500;
-    tSampler_setCrossfadeLength(&player, cfxlen);
-    DBG("cfxlen: " + String(cfxlen));
-    bool state = getButtonState("sample");
+    val = getSliderValue("op");
-    if (state && !lastState)
+    tCrusher_setOperation(&crusher, (int)(val * 8.0f));
-    {
-        timer = 0;
-        tBuffer_record(&sample);
-    }
-    lastState = state;
+    /*
+    float samp = -1.f + 2.f * val;
-    state = getButtonState("play");
+    union unholy_t bw;
+    bw.f = samp;
+    bw.i = (bw.i | (op << 23));
-    if (state && !lastPlayState)
+    DBG(String(samp) + " " + String(bw.f));
-    {
+     */
-        tSampler_play(&player);
-    }
-    lastPlayState = state;
+    // rounding test
+    /*
+    val = getSliderValue("rnd");
+    float to_rnd = -1.f + 2.f * val;
+    float rnd = LEAF_round(to_rnd, 0.3f);
+    DBG("to_rnd: " + String(to_rnd) + " rnd: " + String(rnd));
+     */
 }
 void    LEAFTest_controllerInput (int cnum, float cval)
     }
     leaf_pool_report();
     DBG("ALLOC BUFFER 2");
     size = 25;

Cleaned up some file headers. Implemented tCrusher, bit/sample reduction bitcrusher / shaper.

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code