sigrid/leaf

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

@@ -61,4 +61,4 @@ void tCrusher_setSamplingRatio (tCrusher* const, float ratio); · 60 unmodified lines
61		61
62	#endif // LEAF_WAVEFOLDER_H_INCLUDED	62	#endif // LEAF_WAVEFOLDER_H_INCLUDED
63		63
64	//==============================================================================	64	//==============================================================================

LEAF/Inc/leaf-math.h+6−1

 //==============================================================================
+//==============================================================================
 typedef enum oBool
 {
     OTRUE  = 1,
 float LEAF_round (float input, float rnd);
 float LEAF_bitwise_xor(float input, uint32_t op);
+float LEAF_reduct (float input, float ratio);
+float LEAF_round (float input, float rnd);
+float LEAF_bitwise_xor(float input, uint32_t op);
 float       LEAF_clip               (float min, float val, float max);
 int         LEAF_clipInt            (int min, int val, int max);
 float   	LEAF_softClip		    (float val, float thresh);
 float       LEAF_chebyshevT(float in, int n);
 float       LEAF_CompoundChebyshevT(float in, int n, float* amps);
 // Hermite interpolation
 float LEAF_interpolate_hermite (float A, float B, float C, float D, float t);
 float LEAF_interpolation_linear (float A, float B, float t);

LEAF/Inc/leaf-mempool.h+3−1

@@ -50,7 +50,9 @@ extern "C" { · 49 unmodified lines
50		50
51	//==============================================================================	51	//==============================================================================
52		52
53	#define MPOOL_POOL_SIZE 300000	53
		54	#define MPOOL_POOL_SIZE 500000
		55
54	#define MPOOL_ALIGN_SIZE (8)	56	#define MPOOL_ALIGN_SIZE (8)
55		57
56	//#define size_t unsigned long	58	//#define size_t unsigned long

LEAF/Src/leaf-crusher.c+1−1

@@ -81,4 +81,4 @@ void tCrusher_setRound (tCrusher* const c, float rnd) · 80 unmodified lines
81	void tCrusher_setSamplingRatio (tCrusher* const c, float ratio)	81	void tCrusher_setSamplingRatio (tCrusher* const c, float ratio)
82	{	82	{
83	c->srr = ratio;	83	c->srr = ratio;
84	}	84	}

LEAF/Src/leaf-delay.c+4−6

 void   tTapeDelay_init (tTapeDelay* const d, float delay, uint32_t maxDelay)
 {
     d->maxDelay = maxDelay;
-    d->delay = LEAF_clip(1.f, delay, d->maxDelay);
     d->buff = (float*) leaf_alloc(sizeof(float) * maxDelay);
     d->inc = 1.0f;
     d->inPoint = 0;
-    tTapeDelay_setDelay(d, 1.f);
+    tTapeDelay_setDelay(d, delay);
 }
 void tTapeDelay_free(tTapeDelay* const d)
 int count = 0;
-#define SMOOTH_FACTOR 10.f
+//#define SMOOTH_FACTOR 10.f
 float   tTapeDelay_tick (tTapeDelay* const d, float input)
 {
     float diff = (d->inPoint - d->idx);
     while (diff < 0.f) diff += d->maxDelay;
-    d->inc = 1.0f + (diff - d->delay) / d->delay * SMOOTH_FACTOR;
+    d->inc = 1.0f + (diff - d->delay) / d->delay; //* SMOOTH_FACTOR;
     d->idx += d->inc;
-    if (d->idx >= d->maxDelay) d->idx = 0.f;
+    if (d->idx >= d->maxDelay) d->idx = 0.0f;
     return d->lastOut;
 }

LEAF/Src/leaf-math.c+118−121

 // The C-embedded Audio Library.
 #define TWO_TO_16 65536.f
 #define EXPONENTIAL_TABLE_SIZE 65536
 float interpolate3max(float *buf, const int peakindex)
 {
     alias.f = f;
     alias.ui &= 0x7fffffff;
     return alias.f;
 }
 // dope af
     } else {
         return val;
     }
 }
 oBool     LEAF_isPrime(uint64_t number )
 {
     else
         return x * ( 27 + x * x ) / ( 27 + 9 * x * x );
 }
 void LEAF_generate_sine(float* buffer, int size)
 {
     float phase;
     for (int i = 0; i < size; i++)
     {
         phase = (float) i / (float) size;
         buffer[i] = sinf(phase * TWO_PI);
     }
 }
 void LEAF_generate_sawtooth(float* buffer, float basefreq, int size)
 {
     int harmonic = 1;
     float phase = 0.0f;
     float freq = harmonic * basefreq;
     float amp;
     while (freq < (leaf.sampleRate * 0.5))
     {
         amp = 1.0f / harmonic;
         for (int i = 0; i < size; i++)
         {
             phase = (float) i / (float) size;
             buffer[i] += (amp * sinf(harmonic * phase * TWO_PI));
         }
         harmonic++;
         freq = harmonic * basefreq;
     }
 }
 void LEAF_generate_triangle(float* buffer, float basefreq, int size)
 {
     int harmonic = 1;
     float phase = 0.0f;
     float freq = harmonic * basefreq;
     float amp = 1.0f;
     int count = 0;
     float mult = 1.0f;
     while (freq < (leaf.sampleRate * 0.5))
     {
         amp = 1.0f / (float)(harmonic * harmonic);
         if (count % 2)  mult = -1.0f;
         else            mult =  1.0f;
         for (int i = 0; i < size; i++)
         {
             phase = (float) i / (float) size;
             buffer[i] += (mult * amp * sinf(harmonic * phase * TWO_PI));
         }
         count++;
         harmonic += 2;
         freq = harmonic * basefreq;
     }
 }
 void LEAF_generate_square(float* buffer, float basefreq, int size)
 {
     int harmonic = 1;
     float phase = 0.0f;
     float freq = harmonic * basefreq;
     float amp = 1.0f;
     while (freq < (leaf.sampleRate * 0.5))
     {
         amp = 1.0f / (float)(harmonic);
         for (int i = 0; i < size; i++)
         {
             phase = (float) i / (float) size;
             buffer[i] += (amp * sinf(harmonic * phase * TWO_PI));
         }
         harmonic += 2;
         freq = harmonic * basefreq;
     }
 }
 //-----------------------------------------------------------------------------
 // name: mtof()
 {
     if( f <= -1500.0f ) return (0);
     else if( f > 1499.0f ) return (LEAF_midiToFrequency(1499.0f));
-    else return ( powf(2.0f, (f - 69.0f) / 12.0f) * 440.0f );
+    else return ( powf(2.0f, (f - 69.0f) * 0.083333333333333f) * 440.0f );
 }
 // alpha, [0.0, 1.0]
 float LEAF_interpolate_hermite (float A, float B, float C, float D, float alpha)
 {
     alpha = LEAF_clip(0.0f, alpha, 1.0f);
     float a = -A/2.0f + (3.0f*B)/2.0f - (3.0f*C)/2.0f + D/2.0f;
     float b = A - (5.0f*B)/2.0f + 2.0f*C - D / 2.0f;
     float c = -A/2.0f + C/2.0f;
     float d = B;
     return a*alpha*alpha*alpha + b*alpha*alpha + c*alpha + d;
 }
 // alpha, [0.0, 1.0]
 float LEAF_interpolation_linear (float A, float B, float alpha)
 {
     alpha = LEAF_clip(0.0f, alpha, 1.0f);
     float omAlpha = 1.0f - alpha;
     // First 1/2 of interpolation
     float out = A * omAlpha;
-    out += B * alpha;
-    return out;
-}
+    out += B * alpha;
+    return out;
+}

LEAF/leaf.h+2−0

 #include ".\Inc\leaf-crusher.h"
 #include ".\Inc\leaf-wavefolder.h"
 #include ".\Inc\leaf-wavetables.h"
+#include ".\Inc\leaf-crusher.h"
 #else
 #include "./Inc/leaf-crusher.h"
 #include "./Inc/leaf-wavefolder.h"
 #include "./Inc/leaf-wavetables.h"
+#include "./Inc/leaf-crusher.h"
 #endif

merge fix

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code