notwa/crap
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

it works!

Browse Source
This commit is contained in:
Connor Olding 2015-06-06 17:25:18 -07:00
parent 7bcf6c40d2
commit 5b82fcfac3
14 changed files with 151 additions and 124 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
crap/delay_test.hpp
View File

@ -1,7 +1,3 @@
#include "util.hpp"
typedef unsigned long ulong;
#define ID 0xDEDEDEDE
#define LABEL "crap_delay_test"
#define NAME "crap sample delay test"
@ -10,6 +6,9 @@ typedef unsigned long ulong;
#define PARAMETERS 0
#define DELAY
#include "util.hpp"
#include "biquad.hpp"
static ulong global_delay = 2;
static double oversample = 4;

4
crap/eq.hpp
View File

@ -14,14 +14,14 @@
#include "util.hpp"
#include "param.hpp"
#include "biquad.hpp"
typedef struct {
biquad filters[2][BANDS];
float fs;
} personal;
template<typename T>
static void
TEMPLATE static void
process(personal *data,
T *in_L, T *in_R,
T *out_L, T *out_R,

4
crap/eq_const.hpp
View File

@ -10,14 +10,14 @@
#define BLOCK_SIZE 256
#include "util.hpp"
#include "biquad.hpp"
#define BANDS 12
typedef struct {
biquad filters[2][BANDS];
} personal;
template<typename T>
static void
TEMPLATE static void
process(personal *data,
T *in_L, T *in_R,
T *out_L, T *out_R,

4
crap/eq_const_T420.hpp
View File

@ -10,14 +10,14 @@
#define BLOCK_SIZE 256
#include "util.hpp"
#include "biquad.hpp"
#define BANDS 16
typedef struct {
biquad filters[2][BANDS];
} personal;
template<typename T>
static void
TEMPLATE static void
process(personal *data,
T *in_L, T *in_R,
T *out_L, T *out_R,

52
crap/eq_const_T420_svf.hpp
View File

@ -12,14 +12,14 @@
#define BLOCK_SIZE 256
#include "util.hpp"
#include "svf.hpp"
#define BANDS 16
typedef struct {
svf_matrix filters[2][BANDS];
svf_matrix<v4sf> filters[2][BANDS];
} personal;
template<typename T>
static void
TEMPLATE static void
process(personal *data,
T *in_L, T *in_R,
T *out_L, T *out_R,
@ -32,7 +32,7 @@ process(personal *data,
v4sf buf_L[BLOCK_SIZE/2];
v4sf buf_R[BLOCK_SIZE/2];
svf_matrix *f0, *f1;
svf_matrix<v4sf> *f0, *f1;
for (ulong pos = 0; pos < count; pos += BLOCK_SIZE) {
ulong rem = BLOCK_SIZE;
@ -82,12 +82,10 @@ destruct(personal *data)
INNER void
resume(personal *data)
{
svf_matrix *filters = data->filters[0];
for (int i = 0; i < BANDS; i++) {
filters[i].memory[0] = 0;
filters[i].memory[1] = 0;
}
memcpy(data->filters[1], filters, BANDS*sizeof(svf_matrix));
svf_matrix<v4sf> *filters = data->filters[0];
for (int i = 0; i < BANDS; i++)
filters[i].memory = v4sf(0);
memcpy(data->filters[1], filters, BANDS*sizeof(svf_matrix<v4sf>));
}
INNER void
@ -97,21 +95,21 @@ pause(personal *data)
INNER void
adjust(personal *data, ulong fs)
{
svf_matrix *filters = data->filters[0];
filters[ 0] = svf_gen_matrix(svf_gen(FILT_PEAKING, 180., 11., 1.40, fs));
filters[ 1] = svf_gen_matrix(svf_gen(FILT_PEAKING, 740., 5.5, 0.70, fs));
filters[ 2] = svf_gen_matrix(svf_gen(FILT_PEAKING, 1220, -12., 0.70, fs));
filters[ 3] = svf_gen_matrix(svf_gen(FILT_PEAKING, 1580, 7.0, 0.25, fs));
filters[ 4] = svf_gen_matrix(svf_gen(FILT_PEAKING, 2080, -2.5, 0.30, fs));
filters[ 5] = svf_gen_matrix(svf_gen(FILT_PEAKING, 2270, 6.0, 0.20, fs));
filters[ 6] = svf_gen_matrix(svf_gen(FILT_PEAKING, 2470, -2.0, 0.18, fs));
filters[ 7] = svf_gen_matrix(svf_gen(FILT_PEAKING, 3700, -5.0, 0.32, fs));
filters[ 8] = svf_gen_matrix(svf_gen(FILT_PEAKING, 6200, -3.5, 0.25, fs));
filters[ 9] = svf_gen_matrix(svf_gen(FILT_PEAKING, 6000, -11., 3.66, fs));
filters[10] = svf_gen_matrix(svf_gen(FILT_HIGHSHELF, 11500, 4.0, 0.40, fs));
filters[11] = svf_gen_matrix(svf_gen(FILT_HIGHPASS, 150, 0.0, 1.00, fs));
filters[12] = svf_gen_matrix(svf_gen(FILT_PEAKING, 1775, -2.0, 0.18, fs));
filters[13] = svf_gen_matrix(svf_gen(FILT_PEAKING, 490, -1.5, 0.23, fs));
filters[14] = svf_gen_matrix(svf_gen(FILT_PEAKING, 3100, 5.0, 0.33, fs));
filters[15] = svf_gen_matrix(svf_gen(FILT_LOWPASS, 14000, 0.0, 0.40, fs));
svf_matrix<v4sf> *filters = data->filters[0];
filters[ 0] = svf_gen_matrix<v4sf>(svf_gen(FILT_PEAKING, 180., 11., 1.40, fs));
filters[ 1] = svf_gen_matrix<v4sf>(svf_gen(FILT_PEAKING, 740., 5.5, 0.70, fs));
filters[ 2] = svf_gen_matrix<v4sf>(svf_gen(FILT_PEAKING, 1220, -12., 0.70, fs));
filters[ 3] = svf_gen_matrix<v4sf>(svf_gen(FILT_PEAKING, 1580, 7.0, 0.25, fs));
filters[ 4] = svf_gen_matrix<v4sf>(svf_gen(FILT_PEAKING, 2080, -2.5, 0.30, fs));
filters[ 5] = svf_gen_matrix<v4sf>(svf_gen(FILT_PEAKING, 2270, 6.0, 0.20, fs));
filters[ 6] = svf_gen_matrix<v4sf>(svf_gen(FILT_PEAKING, 2470, -2.0, 0.18, fs));
filters[ 7] = svf_gen_matrix<v4sf>(svf_gen(FILT_PEAKING, 3700, -5.0, 0.32, fs));
filters[ 8] = svf_gen_matrix<v4sf>(svf_gen(FILT_PEAKING, 6200, -3.5, 0.25, fs));
filters[ 9] = svf_gen_matrix<v4sf>(svf_gen(FILT_PEAKING, 6000, -11., 3.66, fs));
filters[10] = svf_gen_matrix<v4sf>(svf_gen(FILT_HIGHSHELF, 11500, 4.0, 0.40, fs));
filters[11] = svf_gen_matrix<v4sf>(svf_gen(FILT_HIGHPASS, 150, 0.0, 1.00, fs));
filters[12] = svf_gen_matrix<v4sf>(svf_gen(FILT_PEAKING, 1775, -2.0, 0.18, fs));
filters[13] = svf_gen_matrix<v4sf>(svf_gen(FILT_PEAKING, 490, -1.5, 0.23, fs));
filters[14] = svf_gen_matrix<v4sf>(svf_gen(FILT_PEAKING, 3100, 5.0, 0.33, fs));
filters[15] = svf_gen_matrix<v4sf>(svf_gen(FILT_LOWPASS, 14000, 0.0, 0.40, fs));
}

58
crap/mugi4.hpp
View File

@ -27,7 +27,7 @@ https://aaltodoc.aalto.fi/bitstream/handle/123456789/14420/article6.pdf
#define VT 0.026
#define N 4
#define VT2 V(2.*VT)
#define VT2 T(2.*VT)
typedef struct {
v2df sum, sumback, dout;
@ -45,55 +45,55 @@ typedef struct {
typedef struct {
ulong fs;
halfband_t hb_up, hb_down;
halfband_t<v2df> hb_up, hb_down;
freqdata fd;
stage s1, s2, s3, s4;
v2df sumback1, sumback2, sumback3, sumback4;
v2df drive, feedback;
} personal;
INNER PURE v2df
tanh2(v2df x)
TEMPLATE INNER PURE T
tanh2(T x)
{
//return (v2df){tanh(x[0]), tanh(x[1])};
v2df xx = x*x;
v2df a = ((xx + V(378.))*xx + V(17325.))*xx + V(135135.);
v2df b = ((V(28.)*xx + V(3150.))*xx + V(62370.))*xx + V(135135.);
//return T(tanh(x[0]), tanh(x[1]));
T xx = x*x;
T a = ((xx + T(378))*xx + T(17325))*xx + T(135135);
T b = ((T(28)*xx + T(3150))*xx + T(62370))*xx + T(135135);
return x*a/b;
}
INNER v2df
process_stage(stage *s, freqdata fd, v2df in)
TEMPLATE INNER T
process_stage(stage *s, freqdata fd, T in)
{
v2df temp = (in + s->sumback)*VT2*fd.L_p0*fd.g;
v2df out = temp + s->sum;
s->sum += V(2.)*temp;
s->dout = tanh2(out/VT2);
T temp = (in + s->sumback)*VT2*fd.L_p0*fd.g;
T out = temp + s->sum;
s->sum += T(2)*temp;
s->dout = tanh2<T>(out/VT2);
s->sumback = in*fd.L_r1 - s->dout*fd.L_q0;
return out;
}
INNER v2df
process_one(v2df in, personal *data)
TEMPLATE INNER T
process_one(T in, personal *data)
{
const freqdata fd = data->fd;
freqdata fd = data->fd;
in *= data->drive;
v2df sum = in + data->sumback1;
v2df pre = -fd.p0*sum;
process_stage(&data->s1, fd, tanh2(pre/VT2));
process_stage(&data->s2, fd, data->s1.dout);
process_stage(&data->s3, fd, data->s2.dout);
v2df out = process_stage(&data->s4, fd, data->s3.dout);
T sum = in + data->sumback1;
T pre = -fd.p0*sum;
process_stage<T>(&data->s1, fd, tanh2<T>(pre/VT2));
process_stage<T>(&data->s2, fd, data->s1.dout);
process_stage<T>(&data->s3, fd, data->s2.dout);
T out = process_stage<T>(&data->s4, fd, data->s3.dout);
v2df back = data->feedback*out;
T back = data->feedback*out;
data->sumback1 = fd.r1*in + fd.q0*back + data->sumback2;
data->sumback2 = fd.r2*in + fd.q1*back + data->sumback3;
data->sumback3 = fd.r3*in + fd.q2*back + data->sumback4;
data->sumback4 = fd.r4*in + fd.q3*back;
v2df compensate = -(data->feedback + V(1.));
T compensate = -(data->feedback + T(1));
return out/data->drive*compensate;
}
@ -108,8 +108,8 @@ process(personal *data,
v2df buf[BLOCK_SIZE];
v2df over[FULL_SIZE];
halfband_t *hb_up = &data->hb_up;
halfband_t *hb_down = &data->hb_down;
halfband_t<v2df> *hb_up = &data->hb_up;
halfband_t<v2df> *hb_down = &data->hb_down;
for (ulong pos = 0; pos < count; pos += BLOCK_SIZE) {
ulong rem = BLOCK_SIZE;
@ -188,8 +188,8 @@ destruct(personal *data)
INNER void
resume(personal *data)
{
memset(&data->hb_up, 0, sizeof(halfband_t));
memset(&data->hb_down, 0, sizeof(halfband_t));
memset(&data->hb_up, 0, sizeof(halfband_t<v2df>));
memset(&data->hb_down, 0, sizeof(halfband_t<v2df>));
}
INNER void

8
crap/tube.hpp
View File

@ -90,8 +90,8 @@ process(personal *data,
}
for (ulong i = 0; i < rem; i++) {
buf[i].v[0] = in_L[i];
buf[i].v[1] = in_R[i];
buf[i][0] = in_L[i];
buf[i][1] = in_R[i];
}
for (ulong i = 0; i < rem; i++) {
@ -109,8 +109,8 @@ process(personal *data,
}
for (ulong i = 0; i < rem; i++) {
out_L[i] = buf[i].v[0];
out_R[i] = buf[i].v[1];
out_L[i] = buf[i][0];
out_R[i] = buf[i][1];
}
in_L += BLOCK_SIZE;

20
include/Dumber.hpp
View File

@ -24,25 +24,25 @@ struct DumberBase {
return *this;
}
inline DumberBase
operator-()
{ return -v; }
inline DumberBase
operator+(const DumberBase &v2)
{ return DumberBase(v + v2.v); }
{ return v + v2.v; }
inline DumberBase
operator-(const DumberBase &v2)
{ return DumberBase(v - v2.v); }
inline DumberBase
operator-()
{ return DumberBase(-v); }
{ return v - v2.v; }
inline DumberBase
operator*(const DumberBase &v2)
{ return DumberBase(v * v2.v); }
{ return v*v2.v; }
inline DumberBase
operator/(const DumberBase &v2)
{ return DumberBase(v / v2.v); }
{ return v/v2.v; }
inline DumberBase&
operator+=(const DumberBase &v2)
@ -61,14 +61,14 @@ struct DumberBase {
inline DumberBase&
operator*=(const DumberBase &v2)
{
v = v * v2.v;
v = v*v2.v;
return *this;
}
inline DumberBase&
operator/=(const DumberBase &v2)
{
v = v / v2.v;
v = v/v2.v;
return *this;
}
};

28
include/biquad.hpp
View File

@ -84,26 +84,26 @@ biquad_run(biquad *bq, double x)
return y;
}
INNER void
TEMPLATE INNER void
biquad_run_block_stereo(biquad *bq_L, biquad *bq_R,
v2df *buf, ulong count)
T *buf, ulong count)
{
v2df b0, b1, b2, a1, a2, x1, x2, y1, y2;
T b0, b1, b2, a1, a2, x1, x2, y1, y2;
b0 = V(bq_L->b0);
b1 = V(bq_L->b1);
b2 = V(bq_L->b2);
a1 = V(bq_L->a1);
a2 = V(bq_L->a2);
b0 = T(bq_L->b0);
b1 = T(bq_L->b1);
b2 = T(bq_L->b2);
a1 = T(bq_L->a1);
a2 = T(bq_L->a2);
x1 = V2(bq_L->x1, bq_R->x1);
x2 = V2(bq_L->x2, bq_R->x2);
y1 = V2(bq_L->y1, bq_R->y1);
y2 = V2(bq_L->y2, bq_R->y2);
x1 = T(bq_L->x1, bq_R->x1);
x2 = T(bq_L->x2, bq_R->x2);
y1 = T(bq_L->y1, bq_R->y1);
y2 = T(bq_L->y2, bq_R->y2);
for (ulong i = 0; i < count; i++) {
v2df x = buf[i];
v2df y = b0*x + b1*x1 + b2*x2 + a1*y1 + a2*y2;
T x = buf[i];
T y = b0*x + b1*x1 + b2*x2 + a1*y1 + a2*y2;
x2 = x1;
y2 = y1;
x1 = x;

1
include/os2piir_stereo.hpp
View File

@ -7,7 +7,6 @@
*/
#define copy(dst, src) memcpy(dst, src, sizeof(T)*8)
//#define copy(dst, src) _copy(dst, src)
// all should be initialized to 0
TEMPLATE

29
include/svf.hpp
View File

@ -8,9 +8,10 @@ typedef struct {
double A0[2], A1[2], B[2], C[3];
} svf_interim;
typedef struct {
v4sf a, b, c, d, memory;
} svf_matrix;
TEMPLATE
struct svf_matrix {
T a, b, c, d, memory;
};
static svf_interim
svf_design(double w0, double Q, double c0, double c1, double c2, double gc)
@ -92,7 +93,7 @@ svf_run(svf *s, float x)
return y;
}
static svf_matrix
TEMPLATE static svf_matrix<T>
svf_gen_matrix(svf s)
{
float AA0[2], AA1[2], AB[2], CA[2], cb;
@ -107,20 +108,20 @@ svf_gen_matrix(svf s)
cb = s.C[1]*s.B[0] + s.C[2]*s.B[1];
svf_matrix mat;
mat.memory = (v4sf){0, 0, 0, 0};
mat.a = (v4sf){s.C[0], 0, s.C[1], s.C[2]};
mat.b = (v4sf){ cb, s.C[0], CA[0], CA[1]};
mat.c = (v4sf){ AB[0], s.B[0], AA0[0], AA0[1]};
mat.d = (v4sf){ AB[1], s.B[1], AA1[0], AA1[1]};
svf_matrix<T> mat;
mat.memory = T(0, 0, 0, 0);
mat.a = T(s.C[0], 0, s.C[1], s.C[2]);
mat.b = T( cb, s.C[0], CA[0], CA[1]);
mat.c = T( AB[0], s.B[0], AA0[0], AA0[1]);
mat.d = T( AB[1], s.B[1], AA1[0], AA1[1]);
return mat;
}
INNER void
svf_run_block_mat(svf_matrix *RESTRICT mat, v4sf *RESTRICT buf, ulong count)
TEMPLATE INNER void
svf_run_block_mat(svf_matrix<T> *RESTRICT mat, T *RESTRICT buf, ulong count)
{
v4sf t1, t2, t3, t4;
v4sf memory = mat->memory;
T t1, t2, t3, t4;
T memory = mat->memory;
for (ulong i = 0; i < count/2; i++) {
memory[0] = buf[i][0];
memory[1] = buf[i][1];

4
include/util.hpp
View File

@ -63,7 +63,3 @@ typedef enum {
FILT_NOTCH,
FILT_GAIN
} filter_t;
// TODO: don't include these here
//#include "biquad.hpp"
//#include "svf.hpp"

50
include/vectors.hpp
View File

@ -10,13 +10,24 @@ struct Dumber<_v2df> : public DumberBase<_v2df> {
inline Dumber() {}
inline Dumber(DumberBase<_v2df> v2) : DumberBase<_v2df>(v2) {}
TEMPLATE inline
Dumber(T x, T y)
template<typename T1, typename T2>
inline
Dumber(T1 x, T2 y)
{ v = (_v2df){double(x), double(y)}; }
TEMPLATE inline
Dumber(T x)
{ v = (_v2df){double(x), double(x)}; }
inline double &
operator[](int index) {
return ((double *)&v)[index];
}
inline const double &
operator[](int index) const {
return ((double *)&v)[index];
}
};
template<>
@ -24,13 +35,24 @@ struct Dumber<_v2sf> : public DumberBase<_v2sf> {
inline Dumber() {}
inline Dumber(DumberBase<_v2sf> v2) : DumberBase<_v2sf>(v2) {}
TEMPLATE inline
Dumber(T x, T y)
template<typename T1, typename T2>
inline
Dumber(T1 x, T2 y)
{ v = (_v2sf){float(x), float(y)}; }
TEMPLATE inline
Dumber(T x)
{ v = (_v2sf){float(x), float(x)}; }
inline float &
operator[](int index) {
return ((float *)&v)[index];
}
inline const float &
operator[](int index) const {
return ((float *)&v)[index];
}
};
template<>
@ -38,17 +60,29 @@ struct Dumber<_v4sf> : public DumberBase<_v4sf> {
inline Dumber() {}
inline Dumber(DumberBase<_v4sf> v2) : DumberBase<_v4sf>(v2) {}
TEMPLATE inline
Dumber(T x, T y, T z, T w)
template<typename T1, typename T2, typename T3, typename T4>
inline
Dumber(T1 x, T2 y, T3 z, T4 w)
{ v = (_v4sf){float(x), float(y), float(z), float(w)}; }
TEMPLATE inline
Dumber(T x, T y)
template<typename T1, typename T2>
inline
Dumber(T1 x, T2 y)
{ v = (_v4sf){float(x), float(y), float(x), float(y)}; }
TEMPLATE inline
Dumber(T x)
{ v = (_v4sf){float(x), float(x), float(x), float(x)}; }
inline float &
operator[](int index) {
return ((float *)&v)[index];
}
inline const float &
operator[](int index) const {
return ((float *)&v)[index];
}
};
typedef Dumber<_v2df> v2df;

6
util/bench.cpp
View File

@ -30,7 +30,7 @@ load_ladspa(char *path)
atexit(cleanup);
LADSPA_Descriptor_Function df;
df = (typeof(df)) dlsym(plug, "ladspa_descriptor");
df = (decltype(df)) dlsym(plug, "ladspa_descriptor");
assert(df);
const LADSPA_Descriptor *d = df(0);
@ -100,7 +100,7 @@ main(int argc, char **argv)
if (LADSPA_IS_PORT_AUDIO(d->PortDescriptors[i]))
audio_count++;
audio_buffer = (typeof(audio_buffer)) calloc(audio_count*BLOCK_SIZE, sizeof(float));
audio_buffer = (decltype(audio_buffer)) calloc(audio_count*BLOCK_SIZE, sizeof(float));
int a = 0;
for (int i = 0; i < d->PortCount; i++) {
@ -108,7 +108,7 @@ main(int argc, char **argv)
d->connect_port(h, i, audio_buffer + a++*BLOCK_SIZE);
} else {
float *x;
x = (typeof(x)) alloca(sizeof(float));
x = (decltype(x)) alloca(sizeof(float));
*x = get_default(d->PortRangeHints[i]);
d->connect_port(h, i, x);
}