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

4
crap/eq.hpp
View file

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

4
crap/eq_const.hpp
View file

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

4
crap/eq_const_T420.hpp
View file

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

52
crap/eq_const_T420_svf.hpp
View file

@ -12,14 +12,14 @@
#define BLOCK_SIZE 256 #define BLOCK_SIZE 256
#include "util.hpp" #include "util.hpp"
#include "svf.hpp"
#define BANDS 16 #define BANDS 16
typedef struct { typedef struct {
svf_matrix filters[2][BANDS]; svf_matrix<v4sf> filters[2][BANDS];
} personal; } personal;
template<typename T> TEMPLATE static void
static void
process(personal *data, process(personal *data,
T *in_L, T *in_R, T *in_L, T *in_R,
T *out_L, T *out_R, T *out_L, T *out_R,
@ -32,7 +32,7 @@ process(personal *data,
v4sf buf_L[BLOCK_SIZE/2]; v4sf buf_L[BLOCK_SIZE/2];
v4sf buf_R[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) { for (ulong pos = 0; pos < count; pos += BLOCK_SIZE) {
ulong rem = BLOCK_SIZE; ulong rem = BLOCK_SIZE;
@ -82,12 +82,10 @@ destruct(personal *data)
INNER void INNER void
resume(personal *data) resume(personal *data)
{ {
svf_matrix *filters = data->filters[0]; svf_matrix<v4sf> *filters = data->filters[0];
for (int i = 0; i < BANDS; i++) { for (int i = 0; i < BANDS; i++)
filters[i].memory[0] = 0; filters[i].memory = v4sf(0);
filters[i].memory[1] = 0; memcpy(data->filters[1], filters, BANDS*sizeof(svf_matrix<v4sf>));
}
memcpy(data->filters[1], filters, BANDS*sizeof(svf_matrix));
} }
INNER void INNER void
@ -97,21 +95,21 @@ pause(personal *data)
INNER void INNER void
adjust(personal *data, ulong fs) adjust(personal *data, ulong fs)
{ {
svf_matrix *filters = data->filters[0]; svf_matrix<v4sf> *filters = data->filters[0];
filters[ 0] = svf_gen_matrix(svf_gen(FILT_PEAKING, 180., 11., 1.40, fs)); filters[ 0] = svf_gen_matrix<v4sf>(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[ 1] = svf_gen_matrix<v4sf>(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[ 2] = svf_gen_matrix<v4sf>(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[ 3] = svf_gen_matrix<v4sf>(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[ 4] = svf_gen_matrix<v4sf>(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[ 5] = svf_gen_matrix<v4sf>(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[ 6] = svf_gen_matrix<v4sf>(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[ 7] = svf_gen_matrix<v4sf>(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[ 8] = svf_gen_matrix<v4sf>(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[ 9] = svf_gen_matrix<v4sf>(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[10] = svf_gen_matrix<v4sf>(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[11] = svf_gen_matrix<v4sf>(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[12] = svf_gen_matrix<v4sf>(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[13] = svf_gen_matrix<v4sf>(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[14] = svf_gen_matrix<v4sf>(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)); 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 VT 0.026
#define N 4 #define N 4
#define VT2 V(2.*VT) #define VT2 T(2.*VT)
typedef struct { typedef struct {
v2df sum, sumback, dout; v2df sum, sumback, dout;
@ -45,55 +45,55 @@ typedef struct {
typedef struct { typedef struct {
ulong fs; ulong fs;
halfband_t hb_up, hb_down; halfband_t<v2df> hb_up, hb_down;
freqdata fd; freqdata fd;
stage s1, s2, s3, s4; stage s1, s2, s3, s4;
v2df sumback1, sumback2, sumback3, sumback4; v2df sumback1, sumback2, sumback3, sumback4;
v2df drive, feedback; v2df drive, feedback;
} personal; } personal;
INNER PURE v2df TEMPLATE INNER PURE T
tanh2(v2df x) tanh2(T x)
{ {
//return (v2df){tanh(x[0]), tanh(x[1])}; //return T(tanh(x[0]), tanh(x[1]));
v2df xx = x*x; T xx = x*x;
v2df a = ((xx + V(378.))*xx + V(17325.))*xx + V(135135.); T a = ((xx + T(378))*xx + T(17325))*xx + T(135135);
v2df b = ((V(28.)*xx + V(3150.))*xx + V(62370.))*xx + V(135135.); T b = ((T(28)*xx + T(3150))*xx + T(62370))*xx + T(135135);
return x*a/b; return x*a/b;
} }
INNER v2df TEMPLATE INNER T
process_stage(stage *s, freqdata fd, v2df in) process_stage(stage *s, freqdata fd, T in)
{ {
v2df temp = (in + s->sumback)*VT2*fd.L_p0*fd.g; T temp = (in + s->sumback)*VT2*fd.L_p0*fd.g;
v2df out = temp + s->sum; T out = temp + s->sum;
s->sum += V(2.)*temp; s->sum += T(2)*temp;
s->dout = tanh2(out/VT2); s->dout = tanh2<T>(out/VT2);
s->sumback = in*fd.L_r1 - s->dout*fd.L_q0; s->sumback = in*fd.L_r1 - s->dout*fd.L_q0;
return out; return out;
} }
INNER v2df TEMPLATE INNER T
process_one(v2df in, personal *data) process_one(T in, personal *data)
{ {
const freqdata fd = data->fd; freqdata fd = data->fd;
in *= data->drive; in *= data->drive;
v2df sum = in + data->sumback1; T sum = in + data->sumback1;
v2df pre = -fd.p0*sum; T pre = -fd.p0*sum;
process_stage(&data->s1, fd, tanh2(pre/VT2)); process_stage<T>(&data->s1, fd, tanh2<T>(pre/VT2));
process_stage(&data->s2, fd, data->s1.dout); process_stage<T>(&data->s2, fd, data->s1.dout);
process_stage(&data->s3, fd, data->s2.dout); process_stage<T>(&data->s3, fd, data->s2.dout);
v2df out = process_stage(&data->s4, fd, data->s3.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->sumback1 = fd.r1*in + fd.q0*back + data->sumback2;
data->sumback2 = fd.r2*in + fd.q1*back + data->sumback3; data->sumback2 = fd.r2*in + fd.q1*back + data->sumback3;
data->sumback3 = fd.r3*in + fd.q2*back + data->sumback4; data->sumback3 = fd.r3*in + fd.q2*back + data->sumback4;
data->sumback4 = fd.r4*in + fd.q3*back; 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; return out/data->drive*compensate;
} }
@ -108,8 +108,8 @@ process(personal *data,
v2df buf[BLOCK_SIZE]; v2df buf[BLOCK_SIZE];
v2df over[FULL_SIZE]; v2df over[FULL_SIZE];
halfband_t *hb_up = &data->hb_up; halfband_t<v2df> *hb_up = &data->hb_up;
halfband_t *hb_down = &data->hb_down; halfband_t<v2df> *hb_down = &data->hb_down;
for (ulong pos = 0; pos < count; pos += BLOCK_SIZE) { for (ulong pos = 0; pos < count; pos += BLOCK_SIZE) {
ulong rem = BLOCK_SIZE; ulong rem = BLOCK_SIZE;
@ -188,8 +188,8 @@ destruct(personal *data)
INNER void INNER void
resume(personal *data) resume(personal *data)
{ {
memset(&data->hb_up, 0, sizeof(halfband_t)); memset(&data->hb_up, 0, sizeof(halfband_t<v2df>));
memset(&data->hb_down, 0, sizeof(halfband_t)); memset(&data->hb_down, 0, sizeof(halfband_t<v2df>));
} }
INNER void INNER void

8
crap/tube.hpp
View file

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

16
include/Dumber.hpp
View file

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

28
include/biquad.hpp
View file

@ -84,26 +84,26 @@ biquad_run(biquad *bq, double x)
return y; return y;
} }
INNER void TEMPLATE INNER void
biquad_run_block_stereo(biquad *bq_L, biquad *bq_R, 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); b0 = T(bq_L->b0);
b1 = V(bq_L->b1); b1 = T(bq_L->b1);
b2 = V(bq_L->b2); b2 = T(bq_L->b2);
a1 = V(bq_L->a1); a1 = T(bq_L->a1);
a2 = V(bq_L->a2); a2 = T(bq_L->a2);
x1 = V2(bq_L->x1, bq_R->x1); x1 = T(bq_L->x1, bq_R->x1);
x2 = V2(bq_L->x2, bq_R->x2); x2 = T(bq_L->x2, bq_R->x2);
y1 = V2(bq_L->y1, bq_R->y1); y1 = T(bq_L->y1, bq_R->y1);
y2 = V2(bq_L->y2, bq_R->y2); y2 = T(bq_L->y2, bq_R->y2);
for (ulong i = 0; i < count; i++) { for (ulong i = 0; i < count; i++) {
v2df x = buf[i]; T x = buf[i];
v2df y = b0*x + b1*x1 + b2*x2 + a1*y1 + a2*y2; T y = b0*x + b1*x1 + b2*x2 + a1*y1 + a2*y2;
x2 = x1; x2 = x1;
y2 = y1; y2 = y1;
x1 = x; 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) memcpy(dst, src, sizeof(T)*8)
//#define copy(dst, src) _copy(dst, src)
// all should be initialized to 0 // all should be initialized to 0
TEMPLATE TEMPLATE

29
include/svf.hpp
View file

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

4
include/util.hpp
View file

@ -63,7 +63,3 @@ typedef enum {
FILT_NOTCH, FILT_NOTCH,
FILT_GAIN FILT_GAIN
} filter_t; } 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() {}
inline Dumber(DumberBase<_v2df> v2) : DumberBase<_v2df>(v2) {} inline Dumber(DumberBase<_v2df> v2) : DumberBase<_v2df>(v2) {}
TEMPLATE inline template<typename T1, typename T2>
Dumber(T x, T y) inline
Dumber(T1 x, T2 y)
{ v = (_v2df){double(x), double(y)}; } { v = (_v2df){double(x), double(y)}; }
TEMPLATE inline TEMPLATE inline
Dumber(T x) Dumber(T x)
{ v = (_v2df){double(x), double(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<> template<>
@ -24,13 +35,24 @@ struct Dumber<_v2sf> : public DumberBase<_v2sf> {
inline Dumber() {} inline Dumber() {}
inline Dumber(DumberBase<_v2sf> v2) : DumberBase<_v2sf>(v2) {} inline Dumber(DumberBase<_v2sf> v2) : DumberBase<_v2sf>(v2) {}
TEMPLATE inline template<typename T1, typename T2>
Dumber(T x, T y) inline
Dumber(T1 x, T2 y)
{ v = (_v2sf){float(x), float(y)}; } { v = (_v2sf){float(x), float(y)}; }
TEMPLATE inline TEMPLATE inline
Dumber(T x) Dumber(T x)
{ v = (_v2sf){float(x), float(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<> template<>
@ -38,17 +60,29 @@ struct Dumber<_v4sf> : public DumberBase<_v4sf> {
inline Dumber() {} inline Dumber() {}
inline Dumber(DumberBase<_v4sf> v2) : DumberBase<_v4sf>(v2) {} inline Dumber(DumberBase<_v4sf> v2) : DumberBase<_v4sf>(v2) {}
TEMPLATE inline template<typename T1, typename T2, typename T3, typename T4>
Dumber(T x, T y, T z, T w) inline
Dumber(T1 x, T2 y, T3 z, T4 w)
{ v = (_v4sf){float(x), float(y), float(z), float(w)}; } { v = (_v4sf){float(x), float(y), float(z), float(w)}; }
TEMPLATE inline template<typename T1, typename T2>
Dumber(T x, T y) inline
Dumber(T1 x, T2 y)
{ v = (_v4sf){float(x), float(y), float(x), float(y)}; } { v = (_v4sf){float(x), float(y), float(x), float(y)}; }
TEMPLATE inline TEMPLATE inline
Dumber(T x) Dumber(T x)
{ v = (_v4sf){float(x), float(x), float(x), float(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; typedef Dumber<_v2df> v2df;

6
util/bench.cpp
View file

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