begin work on class-based plugins

ladspa/crap_eq is working, seemingly.

Makefile

@@ -10,7 +10,7 @@ LADSPA = $(BOTH)
 VST = $(BOTH) delay_test
 
 UTILS = design bench
-INCLUDES = util biquad svf param os6iir os2piir
+INCLUDES = util Crap biquad svf param os6iir os2piir
 
 BENCH_AGAINST = eq_const
 

README.md

@@ -42,3 +42,4 @@ other targets:
 * rename plugins (fix capitalization consistency and such)
 * scrap overly-complex makefile for a shell script
 * support for CPUs without SSE/NEON
+* don't mix CamelCase with underscores (only done for legacy reasons)

crap/eq.hpp

@@ -13,25 +13,21 @@
 
 #include "util.hpp"
 #include "param.hpp"
+#include "Crap.hpp"
 #include "biquad.hpp"
 
-typedef struct {
+template<class Mixin>
-	biquad filters[2][BANDS];
+struct Buffer2 : public virtual Mixin {
-	float fs;
+	virtual inline void
-} personal;
+	process2(v2df *buf, ulong rem) = 0;
 
-TEMPLATE static void
+	TEMPLATE void
-process(personal *data,
+	_process(T *in_L, T *in_R, T *out_L, T *out_R, ulong count)
-    T *in_L, T *in_R,
+	{
-    T *out_L, T *out_R,
-    unsigned long count)
-{
 		disable_denormals();
 
 		v2df buf[BLOCK_SIZE];
 
-	biquad *f0, *f1;
-
 		for (ulong pos = 0; pos < count; pos += BLOCK_SIZE) {
 			ulong rem = BLOCK_SIZE;
 			if (pos + BLOCK_SIZE > count)
@@ -42,13 +38,7 @@ process(personal *data,
 				buf[i][1] = in_R[i];
 			}
 
-		f0 = data->filters[0];
+			process2(buf, rem);
-		f1 = data->filters[1];
-		for (ulong i = 0; i < BANDS; i++) {
-			biquad_run_block_stereo(f0, f1, buf, rem);
-			f0++;
-			f1++;
-		}
 
 			for (ulong i = 0; i < rem; i++) {
 				out_L[i] = buf[i][0];
@@ -60,24 +50,65 @@ process(personal *data,
 			out_L += BLOCK_SIZE;
 			out_R += BLOCK_SIZE;
 		}
-}
+	}
 
-INNER void
+	void
-resume(personal *data)
+	process(
-{
+	    double *in_L, double *in_R,
-	biquad *filters = data->filters[0];
+	    double *out_L, double *out_R,
-	for (int i = 0; i < BANDS; i++)
+	    ulong count)
-		biquad_init(&filters[i]);
+	{
-	memcpy(data->filters[1], filters, BANDS*sizeof(biquad));
+		_process(in_L, in_R, out_L, out_R, count);
-}
+	}
 
-INNER void
+	void
-pause(personal *data)
+	process(
-{}
+	    float *in_L, float *in_R,
+	    float *out_L, float *out_R,
+	    ulong count)
+	{
+		_process(in_L, in_R, out_L, out_R, count);
+	}
+};
 
-INNER void
+struct Crap_eq
-construct_params(param *params)
+:public Unconstructive<
-{
+	 AdjustAll<
+	  Buffer2<Crap>
+	 >
+	> {
+	biquad filters_L[BANDS];
+	biquad filters_R[BANDS];
+
+	inline void
+	process2(v2df *buf, ulong rem)
+	{
+		biquad *f0, *f1;
+		f0 = filters_L;
+		f1 = filters_R;
+		for (ulong i = 0; i < BANDS; i++) {
+			biquad_run_block_stereo(f0, f1, buf, rem);
+			f0++;
+			f1++;
+		}
+	}
+
+	inline void
+	pause()
+	{}
+
+	inline void
+	resume()
+	{
+		for (int i = 0; i < BANDS; i++) {
+			biquad_init(&filters_L[i]);
+			biquad_init(&filters_R[i]);
+		}
+	}
+
+	static inline void
+	construct_params(param *params)
+	{
 		for (int i = 0; i < BANDS; i++) {
 			sprintf(params[0].name, "Band %i Frequency", i + 1);
 			params[0].min = 20;
@@ -102,35 +133,16 @@ construct_params(param *params)
 
 			params += 3;
 		}
-}
-
-INNER void
-construct(personal *data)
-{}
-
-INNER void
-destruct(personal *data)
-{}
-
-INNER void
-adjust(personal *data, param *params, unsigned long fs)
-{
-	data->fs = fs;
-	biquad *filters = data->filters[0];
-	for (int i = 0; i < BANDS; i++) {
-		filters[i] = biquad_gen(FILT_PEAKING,
-		    params[0].value, params[1].value, params[2].value, fs);
-		params += 3;
 	}
-	resume(data);
-}
 
-INNER void
+	inline void
-adjust_one(personal *data, param *params, unsigned int index)
+	adjust_all(param *params)
-{
+	{
-	float fs = data->fs;
+		for (int i = 0; i < BANDS; i++) {
-	params += index/3*3;
+			filters_L[i] = biquad_gen(FILT_PEAKING,
-	data->filters[0][index/3] = biquad_gen(FILT_PEAKING,
+			    params[0].value, params[1].value, params[2].value, (double) fs);
-	    params[0].value, params[1].value, params[2].value, fs);
+			params += 3;
-	resume(data);
+			filters_R[i] = filters_L[i];
-}
+		}
+	}
+};

include/Crap.hpp

@@ -0,0 +1,85 @@
+struct Crap {
+	virtual inline
+	~Crap() {}
+
+	virtual inline void
+	construct() = 0;
+
+	virtual inline void
+	destruct() = 0;
+
+	virtual void
+	pause() = 0;
+
+	virtual void
+	resume() = 0;
+
+	virtual void
+	process(
+	    double *in_L, double *in_R,
+	    double *out_L, double *out_R,
+	    ulong count) = 0;
+
+	virtual void
+	process(
+	    float *in_L, float *in_R,
+	    float *out_L, float *out_R,
+	    ulong count) = 0;
+
+	//void
+	//construct_params(param *params) = 0;
+
+	virtual void
+	adjust(param *params, ulong fs) = 0;
+
+	virtual void
+	adjust_one(param *params, int i) = 0;
+};
+
+template<class Mixin>
+struct AdjustAll : public virtual Mixin {
+	ulong fs;
+
+	virtual void
+	adjust_all(param *params) = 0;
+
+	inline void
+	adjust(param *params, ulong fs_new)
+	{
+		fs = fs_new;
+		adjust_all(params);
+	}
+
+	inline void
+	adjust_one(param *params, int i)
+	{
+		adjust_all(params);
+	}
+};
+
+template<class Mixin>
+struct Unconstructive : public virtual Mixin {
+	inline void
+	construct()
+	{};
+
+	inline void
+	destruct()
+	{};
+};
+
+template<class Mixin>
+struct NoParams : public virtual Mixin {
+	// etc
+
+	//void
+	//construct_params(param *params) = 0;
+
+	void
+	adjust(param *params, ulong fs)
+	{}
+
+	void
+	adjust_one(param *params, int i)
+	{}
+};

template/ladspa.cpp

@@ -2,6 +2,7 @@
 #include "ladspa.hpp"
 
 //#INCLUDE
+//#REDEFINE
 
 #ifndef PARAM_NAME_LEN
 #define PARAM_NAME_LEN 24
@@ -33,7 +34,7 @@ typedef struct {
 	LADSPA_Data *output_L;
 	LADSPA_Data *output_R;
 
-	personal data;
+	Crap *crap;
 	#if (PARAMETERS > 0)
 	LADSPA_Data *values[PARAMETERS];
 	param params[PARAMETERS];
@@ -62,26 +63,27 @@ static void
 plug_resume(LADSPA_Handle instance)
 {
 	plug_t *plug = (plug_t *)instance;
-	resume(&plug->data);
+	plug->crap->resume();
 }
 
 static void
 plug_pause(LADSPA_Handle instance)
 {
 	plug_t *plug = (plug_t *)instance;
-	pause(&plug->data);
+	plug->crap->pause();
 }
 
 static LADSPA_Handle
 plug_construct(const LADSPA_Descriptor *descriptor, unsigned long fs)
 {
 	plug_t *plug = (plug_t *) calloc(1, sizeof(plug_t));
-	construct(&plug->data);
+	plug->crap = new CrapPlug();
+	plug->crap->construct();
 	#if (PARAMETERS > 0)
 	memcpy(plug->params, global_params, sizeof(param)*PARAMETERS);
-	adjust(&plug->data, plug->params, fs);
+	plug->crap->adjust(plug->params, fs);
 	#else
-	adjust(&plug->data, fs);
+	plug->crap->adjust(NULL, fs);
 	#endif
 	return (LADSPA_Handle) plug;
 }
@@ -90,7 +92,8 @@ static void
 plug_destruct(LADSPA_Handle instance)
 {
 	plug_t *plug = (plug_t *)instance;
-	destruct(&plug->data);
+	plug->crap->destruct();
+	delete plug->crap;
 	free(plug);
 }
 
@@ -104,11 +107,11 @@ plug_process(LADSPA_Handle instance, unsigned long count)
 			continue;
 		if (*plug->values[i] != plug->params[i].value) {
 			plug->params[i].value = *plug->values[i];
-			adjust_one(&plug->data, plug->params, i);
+			plug->crap->adjust_one(plug->params, i);
 		}
 	}
 	#endif
-	process(&plug->data,
+	plug->crap->process(
 	    plug->input_L, plug->input_R,
 	    plug->output_L, plug->output_R,
 	    count);
@@ -155,7 +158,7 @@ plug_init()
 	}
 
 	#if (PARAMETERS > 0)
-	construct_params(global_params);
+	CrapPlug::construct_params(global_params);
 	for (int i = 0; i < PARAMETERS; i++) {
 		int j = i + 4;
 		param *p = &global_params[i];

util/generate

@@ -2,7 +2,10 @@
 set -e
 set -u
 
+pp_class="${1%*.hpp}"
+pp_class="${pp_class#crap/*}"
 pp_include="#include \"$1\""
+pp_redefine="#define CrapPlug Crap_$pp_class"
 out="$2"
 template="$3"
 
@@ -10,6 +13,7 @@ template="$3"
     case "$REPLY" in
 
     '//#INCLUDE') echo "$pp_include" ;;
+    '//#REDEFINE') echo "$pp_redefine" ;;
 
     *) echo -E "$REPLY" ;;
     esac