[SCM] calf/master: + EQ-8, EQ-12: reduce copypasta by using a class template
js at users.alioth.debian.org
js at users.alioth.debian.org
Tue May 7 15:39:49 UTC 2013
The following commit has been merged in the master branch:
commit cf7eaaf5c0c7b9bebf5df24024a1680c35a96702
Author: Krzysztof Foltman <wdev at foltman.com>
Date: Sun Nov 15 18:58:42 2009 +0000
+ EQ-8, EQ-12: reduce copypasta by using a class template
diff --git a/src/calf/giface.h b/src/calf/giface.h
index 92cb1f9..a41db4c 100644
--- a/src/calf/giface.h
+++ b/src/calf/giface.h
@@ -26,6 +26,7 @@
#include <pthread.h>
#include <exception>
#include <string>
+#include <complex>
#include "primitives.h"
#include "preset.h"
@@ -563,9 +564,37 @@ public:
static const char *impl_get_id() { return id; } \
static const char *impl_get_label() { return label; } \
-
extern const char *calf_copyright_info;
+bool get_freq_gridline(int subindex, float &pos, bool &vertical, std::string &legend, cairo_iface *context, bool use_frequencies = true);
+
+/// convert amplitude value to normalized grid-ish value (0dB = 0.5, 30dB = 1.0, -30 dB = 0.0, -60dB = -0.5, -90dB = -1.0)
+static inline float dB_grid(float amp)
+{
+ return log(amp) * (1.0 / log(256.0)) + 0.4;
+}
+
+template<class Fx>
+static bool get_graph(Fx &fx, int subindex, float *data, int points)
+{
+ for (int i = 0; i < points; i++)
+ {
+ typedef std::complex<double> cfloat;
+ double freq = 20.0 * pow (20000.0 / 20.0, i * 1.0 / points);
+ data[i] = dB_grid(fx.freq_gain(subindex, freq, fx.srate));
+ }
+ return true;
+}
+
+/// convert normalized grid-ish value back to amplitude value
+static inline float dB_grid_inv(float pos)
+{
+ return pow(256.0, pos - 0.4);
+}
+
+/// set drawing color based on channel index (0 or 1)
+void set_channel_color(cairo_iface *context, int channel);
+
};
#endif
diff --git a/src/calf/metadata.h b/src/calf/metadata.h
index 2ba9e02..a992590 100644
--- a/src/calf/metadata.h
+++ b/src/calf/metadata.h
@@ -92,6 +92,12 @@ public:
PLUGIN_NAME_ID_LABEL("multichorus", "multichorus", "Multi Chorus")
};
+enum CalfEqMode {
+ MODE12DB,
+ MODE24DB,
+ MODE36DB
+};
+
/// Monosynth - metadata
struct monosynth_metadata: public plugin_metadata<monosynth_metadata>
{
@@ -211,6 +217,7 @@ struct equalizer8band_metadata: public plugin_metadata<equalizer8band_metadata>
param_p3_active, param_p3_level, param_p3_freq, param_p3_q,
param_p4_active, param_p4_level, param_p4_freq, param_p4_q,
param_count };
+ enum { PeakBands = 4, first_graph_param = param_hp_active, last_graph_param = param_p4_q };
PLUGIN_NAME_ID_LABEL("equalizer8band", "equalizer8band", "Equalizer 8 Band")
};
/// Markus's 12-band EQ - metadata
@@ -232,6 +239,7 @@ struct equalizer12band_metadata: public plugin_metadata<equalizer12band_metadata
param_p7_active, param_p7_level, param_p7_freq, param_p7_q,
param_p8_active, param_p8_level, param_p8_freq, param_p8_q,
param_count };
+ enum { PeakBands = 8, first_graph_param = param_hp_active, last_graph_param = param_p8_q };
PLUGIN_NAME_ID_LABEL("equalizer12band", "equalizer12band", "Equalizer 12 Band")
};
diff --git a/src/calf/modules.h b/src/calf/modules.h
index 5f42b36..6c9008a 100644
--- a/src/calf/modules.h
+++ b/src/calf/modules.h
@@ -37,7 +37,7 @@ namespace calf_plugins {
using namespace dsp;
struct ladspa_plugin_info;
-
+
#if 0
class amp_audio_module: public null_audio_module
{
@@ -1038,120 +1038,28 @@ public:
int get_changed_offsets(int index, int generation, int &subindex_graph, int &subindex_dot, int &subindex_gridline);
};
-/// Equalizer 12 Band by Markus Schmidt (based on Krzysztof's filters)
-class equalizer12band_audio_module: public audio_module<equalizer12band_metadata>, public frequency_response_line_graph {
-private:
- float hp_mode_old, hp_freq_old;
- float lp_mode_old, lp_freq_old;
- float ls_level_old, ls_freq_old;
- float hs_level_old, hs_freq_old;
- float p_level_old[8], p_freq_old[8], p_q_old[8];
- float hp_mode_old1, hp_freq_old1, hp_active_old1;
- float lp_mode_old1, lp_freq_old1, lp_active_old1;
- float ls_level_old1, ls_freq_old1, ls_active_old1;
- float hs_level_old1, hs_freq_old1, hs_active_old1;
- float p_level_old1[8], p_freq_old1[8], p_q_old1[8], p_active_old1[8];
- enum CalfEqModes {
- MODE12DB,
- MODE24DB,
- MODE36DB
- };
- CalfEqModes eq_mode, eq_mode_old1[2];
- uint32_t clip_inL, clip_outL, clip_inR, clip_outR;
- float meter_inL, meter_outL, meter_inR, meter_outR;
- biquad_d2<float> hpL[3], hpR[3], lpL[3], lpR[3];
- biquad_d2<float> lsL, lsR, hsL, hsR;
- biquad_d2<float> pL[8], pR[8];
+/// Equalizer N Band by Markus Schmidt (based on Krzysztof's filters)
+template<class BaseClass>
+class equalizerNband_audio_module: public audio_module<BaseClass>, public frequency_response_line_graph {
public:
- typedef std::complex<double> cfloat;
- float *ins[in_count];
- float *outs[out_count];
- float *params[param_count];
- uint32_t srate;
- bool is_active;
- volatile int last_generation, last_calculated_generation;
- equalizer12band_audio_module();
- void activate();
- void deactivate();
- void params_changed();
- float freq_gain(int index, double freq, uint32_t sr)
- {
- float ret = 1.f;
- if(*params[param_hp_active] > 0.f) {
- switch((int)*params[param_hp_mode]) {
- case MODE12DB:
- ret *= hpL[0].freq_gain(freq, sr);
- ret *= hpR[0].freq_gain(freq, sr);
- break;
- case MODE24DB:
- ret *= hpL[0].freq_gain(freq, sr) * hpL[0].freq_gain(freq, sr);
- ret *= hpR[0].freq_gain(freq, sr) * hpR[0].freq_gain(freq, sr);
- break;
- case MODE36DB:
- ret *= hpL[0].freq_gain(freq, sr) * hpL[0].freq_gain(freq, sr) * hpL[0].freq_gain(freq, sr);
- ret *= hpR[0].freq_gain(freq, sr) * hpR[0].freq_gain(freq, sr) * hpR[0].freq_gain(freq, sr);
- break;
- }
- }
- if(*params[param_lp_active] > 0.f) {
- switch((int)*params[param_lp_mode]) {
- case MODE12DB:
- ret *= lpL[0].freq_gain(freq, sr);
- ret *= lpR[0].freq_gain(freq, sr);
- break;
- case MODE24DB:
- ret *= lpL[0].freq_gain(freq, sr) * lpL[0].freq_gain(freq, sr);
- ret *= lpR[0].freq_gain(freq, sr) * lpR[0].freq_gain(freq, sr);
- break;
- case MODE36DB:
- ret *= lpL[0].freq_gain(freq, sr) * lpL[0].freq_gain(freq, sr) * lpL[0].freq_gain(freq, sr);
- ret *= lpR[0].freq_gain(freq, sr) * lpR[0].freq_gain(freq, sr) * lpR[0].freq_gain(freq, sr);
- break;
- }
- }
- ret *= (*params[param_ls_active] > 0.f) ? lsL.freq_gain(freq, sr) : 1;
- ret *= (*params[param_hs_active] > 0.f) ? hsL.freq_gain(freq, sr) : 1;
- ret *= (*params[param_p1_active] > 0.f) ? pL[0].freq_gain(freq, sr) : 1;
- ret *= (*params[param_p2_active] > 0.f) ? pL[1].freq_gain(freq, sr) : 1;
- ret *= (*params[param_p3_active] > 0.f) ? pL[2].freq_gain(freq, sr) : 1;
- ret *= (*params[param_p4_active] > 0.f) ? pL[3].freq_gain(freq, sr) : 1;
- ret *= (*params[param_p5_active] > 0.f) ? pL[4].freq_gain(freq, sr) : 1;
- ret *= (*params[param_p6_active] > 0.f) ? pL[5].freq_gain(freq, sr) : 1;
- ret *= (*params[param_p7_active] > 0.f) ? pL[6].freq_gain(freq, sr) : 1;
- ret *= (*params[param_p8_active] > 0.f) ? pL[7].freq_gain(freq, sr) : 1;
- return ret;
- }
- void set_sample_rate(uint32_t sr);
- uint32_t process(uint32_t offset, uint32_t numsamples, uint32_t inputs_mask, uint32_t outputs_mask);
- bool get_graph(int index, int subindex, float *data, int points, cairo_iface *context);
- bool get_gridline(int index, int subindex, float &pos, bool &vertical, std::string &legend, cairo_iface *context);
- int get_changed_offsets(int index, int generation, int &subindex_graph, int &subindex_dot, int &subindex_gridline);
-};
-
-/// Equalizer 8 Band by Markus Schmidt (based on Krzysztof's filters)
-class equalizer8band_audio_module: public audio_module<equalizer8band_metadata>, public frequency_response_line_graph {
+ typedef audio_module<BaseClass> AM;
+ using AM::in_count;
+ using AM::out_count;
+ using AM::param_count;
+ using AM::PeakBands;
private:
+ enum { graph_param_count = BaseClass::last_graph_param - BaseClass::first_graph_param + 1, params_per_band = AM::param_p2_active - AM::param_p1_active };
float hp_mode_old, hp_freq_old;
float lp_mode_old, lp_freq_old;
float ls_level_old, ls_freq_old;
float hs_level_old, hs_freq_old;
- float p_level_old[4], p_freq_old[4], p_q_old[4];
- float hp_mode_old1, hp_freq_old1, hp_active_old1;
- float lp_mode_old1, lp_freq_old1, lp_active_old1;
- float ls_level_old1, ls_freq_old1, ls_active_old1;
- float hs_level_old1, hs_freq_old1, hs_active_old1;
- float p_level_old1[4], p_freq_old1[4], p_q_old1[4], p_active_old1[4];
- enum CalfEqModes {
- MODE12DB,
- MODE24DB,
- MODE36DB
- };
- CalfEqModes eq_mode, eq_mode_old1[2];
+ float p_level_old[PeakBands], p_freq_old[PeakBands], p_q_old[PeakBands];
+ float old_params_for_graph[graph_param_count];
uint32_t clip_inL, clip_outL, clip_inR, clip_outR;
float meter_inL, meter_outL, meter_inR, meter_outR;
- biquad_d2<float> hpL[3], hpR[3], lpL[3], lpR[3];
+ biquad_d2<float> hp[3][2], lp[3][2];
biquad_d2<float> lsL, lsR, hsL, hsR;
- biquad_d2<float> pL[4], pR[4];
+ biquad_d2<float> pL[PeakBands], pR[PeakBands];
public:
typedef std::complex<double> cfloat;
float *ins[in_count];
@@ -1160,60 +1068,24 @@ public:
uint32_t srate;
bool is_active;
volatile int last_generation, last_calculated_generation;
- equalizer8band_audio_module();
+ equalizerNband_audio_module();
void activate();
void deactivate();
void params_changed();
- float freq_gain(int index, double freq, uint32_t sr)
+ float freq_gain(int index, double freq, uint32_t sr);
+ void set_sample_rate(uint32_t sr)
{
- float ret = 1.f;
- if(*params[param_hp_active] > 0.f) {
- switch((int)*params[param_hp_mode]) {
- case MODE12DB:
- ret *= hpL[0].freq_gain(freq, sr);
- ret *= hpR[0].freq_gain(freq, sr);
- break;
- case MODE24DB:
- ret *= hpL[0].freq_gain(freq, sr) * hpL[0].freq_gain(freq, sr);
- ret *= hpR[0].freq_gain(freq, sr) * hpR[0].freq_gain(freq, sr);
- break;
- case MODE36DB:
- ret *= hpL[0].freq_gain(freq, sr) * hpL[0].freq_gain(freq, sr) * hpL[0].freq_gain(freq, sr);
- ret *= hpR[0].freq_gain(freq, sr) * hpR[0].freq_gain(freq, sr) * hpR[0].freq_gain(freq, sr);
- break;
- }
- }
- if(*params[param_lp_active] > 0.f) {
- switch((int)*params[param_lp_mode]) {
- case MODE12DB:
- ret *= lpL[0].freq_gain(freq, sr);
- ret *= lpR[0].freq_gain(freq, sr);
- break;
- case MODE24DB:
- ret *= lpL[0].freq_gain(freq, sr) * lpL[0].freq_gain(freq, sr);
- ret *= lpR[0].freq_gain(freq, sr) * lpR[0].freq_gain(freq, sr);
- break;
- case MODE36DB:
- ret *= lpL[0].freq_gain(freq, sr) * lpL[0].freq_gain(freq, sr) * lpL[0].freq_gain(freq, sr);
- ret *= lpR[0].freq_gain(freq, sr) * lpR[0].freq_gain(freq, sr) * lpR[0].freq_gain(freq, sr);
- break;
- }
- }
- ret *= (*params[param_ls_active] > 0.f) ? lsL.freq_gain(freq, sr) : 1;
- ret *= (*params[param_hs_active] > 0.f) ? hsL.freq_gain(freq, sr) : 1;
- ret *= (*params[param_p1_active] > 0.f) ? pL[0].freq_gain(freq, sr) : 1;
- ret *= (*params[param_p2_active] > 0.f) ? pL[1].freq_gain(freq, sr) : 1;
- ret *= (*params[param_p3_active] > 0.f) ? pL[2].freq_gain(freq, sr) : 1;
- ret *= (*params[param_p4_active] > 0.f) ? pL[3].freq_gain(freq, sr) : 1;
- return ret;
+ srate = sr;
}
- void set_sample_rate(uint32_t sr);
uint32_t process(uint32_t offset, uint32_t numsamples, uint32_t inputs_mask, uint32_t outputs_mask);
bool get_graph(int index, int subindex, float *data, int points, cairo_iface *context);
bool get_gridline(int index, int subindex, float &pos, bool &vertical, std::string &legend, cairo_iface *context);
int get_changed_offsets(int index, int generation, int &subindex_graph, int &subindex_dot, int &subindex_gridline);
};
+typedef equalizerNband_audio_module<equalizer8band_metadata> equalizer8band_audio_module;
+typedef equalizerNband_audio_module<equalizer12band_metadata> equalizer12band_audio_module;
+
/// Equalizer 5 Band by Markus Schmidt (based on Krzysztof's filters)
class equalizer5band_audio_module: public audio_module<equalizer5band_metadata>, public frequency_response_line_graph {
private:
diff --git a/src/giface.cpp b/src/giface.cpp
index 5bbbf76..bc04077 100644
--- a/src/giface.cpp
+++ b/src/giface.cpp
@@ -235,6 +235,63 @@ bool calf_plugins::check_for_string_ports(parameter_properties *parameters, int
return false;
}
+bool calf_plugins::get_freq_gridline(int subindex, float &pos, bool &vertical, std::string &legend, cairo_iface *context, bool use_frequencies)
+{
+ if (subindex < 0 )
+ return false;
+ if (use_frequencies)
+ {
+ if (subindex < 28)
+ {
+ vertical = true;
+ if (subindex == 9) legend = "100 Hz";
+ if (subindex == 18) legend = "1 kHz";
+ if (subindex == 27) legend = "10 kHz";
+ float freq = 100;
+ if (subindex < 9)
+ freq = 10 * (subindex + 1);
+ else if (subindex < 18)
+ freq = 100 * (subindex - 9 + 1);
+ else if (subindex < 27)
+ freq = 1000 * (subindex - 18 + 1);
+ else
+ freq = 10000 * (subindex - 27 + 1);
+ pos = log(freq / 20.0) / log(1000);
+ if (!legend.empty())
+ context->set_source_rgba(0, 0, 0, 0.2);
+ else
+ context->set_source_rgba(0, 0, 0, 0.1);
+ return true;
+ }
+ subindex -= 28;
+ }
+ if (subindex >= 32)
+ return false;
+ float gain = 16.0 / (1 << subindex);
+ pos = dB_grid(gain);
+ if (pos < -1)
+ return false;
+ if (subindex != 4)
+ context->set_source_rgba(0, 0, 0, subindex & 1 ? 0.1 : 0.2);
+ if (!(subindex & 1))
+ {
+ std::stringstream ss;
+ ss << (24 - 6 * subindex) << " dB";
+ legend = ss.str();
+ }
+ vertical = false;
+ return true;
+}
+
+void calf_plugins::set_channel_color(cairo_iface *context, int channel)
+{
+ if (channel & 1)
+ context->set_source_rgba(0.35, 0.4, 0.2, 1);
+ else
+ context->set_source_rgba(0.35, 0.4, 0.2, 0.5);
+ context->set_line_width(1.5);
+}
+
#if USE_DSSI
struct osc_cairo_control: public cairo_iface
{
@@ -322,4 +379,5 @@ calf_plugins::dssi_feedback_sender::~dssi_feedback_sender()
// client->send("/iQuit");
delete client;
}
+
#endif
diff --git a/src/modules.cpp b/src/modules.cpp
index 77c0eac..31c180e 100644
--- a/src/modules.cpp
+++ b/src/modules.cpp
@@ -31,7 +31,7 @@
using namespace dsp;
using namespace calf_plugins;
-const char *calf_plugins::calf_copyright_info = "(C) 2001-2008 Krzysztof Foltman, license: LGPL";
+const char *calf_plugins::calf_copyright_info = "(C) 2001-2009 Krzysztof Foltman, Thor Harald Johanssen, Markus Schmidt and others; license: LGPL";
////////////////////////////////////////////////////////////////////////////
diff --git a/src/modules_dsp.cpp b/src/modules_dsp.cpp
index 79a0be0..352ea90 100644
--- a/src/modules_dsp.cpp
+++ b/src/modules_dsp.cpp
@@ -32,87 +32,6 @@
using namespace dsp;
using namespace calf_plugins;
-/// convert amplitude value to normalized grid-ish value (0dB = 0.5, 30dB = 1.0, -30 dB = 0.0, -60dB = -0.5, -90dB = -1.0)
-static inline float dB_grid(float amp)
-{
- return log(amp) * (1.0 / log(256.0)) + 0.4;
-}
-
-template<class Fx>
-static bool get_graph(Fx &fx, int subindex, float *data, int points)
-{
- for (int i = 0; i < points; i++)
- {
- typedef std::complex<double> cfloat;
- double freq = 20.0 * pow (20000.0 / 20.0, i * 1.0 / points);
- data[i] = dB_grid(fx.freq_gain(subindex, freq, fx.srate));
- }
- return true;
-}
-
-/// convert normalized grid-ish value back to amplitude value
-static inline float dB_grid_inv(float pos)
-{
- return pow(256.0, pos - 0.4);
-}
-
-static void set_channel_color(cairo_iface *context, int channel)
-{
- if (channel & 1)
- context->set_source_rgba(0.35, 0.4, 0.2, 1);
- else
- context->set_source_rgba(0.35, 0.4, 0.2, 0.5);
- context->set_line_width(1.5);
-}
-
-static bool get_freq_gridline(int subindex, float &pos, bool &vertical, std::string &legend, cairo_iface *context, bool use_frequencies = true)
-{
- if (subindex < 0 )
- return false;
- if (use_frequencies)
- {
- if (subindex < 28)
- {
- vertical = true;
- if (subindex == 9) legend = "100 Hz";
- if (subindex == 18) legend = "1 kHz";
- if (subindex == 27) legend = "10 kHz";
- float freq = 100;
- if (subindex < 9)
- freq = 10 * (subindex + 1);
- else if (subindex < 18)
- freq = 100 * (subindex - 9 + 1);
- else if (subindex < 27)
- freq = 1000 * (subindex - 18 + 1);
- else
- freq = 10000 * (subindex - 27 + 1);
- pos = log(freq / 20.0) / log(1000);
- if (!legend.empty())
- context->set_source_rgba(0, 0, 0, 0.2);
- else
- context->set_source_rgba(0, 0, 0, 0.1);
- return true;
- }
- subindex -= 28;
- }
- if (subindex >= 32)
- return false;
- float gain = 16.0 / (1 << subindex);
- pos = dB_grid(gain);
- if (pos < -1)
- return false;
- if (subindex != 4)
- context->set_source_rgba(0, 0, 0, subindex & 1 ? 0.1 : 0.2);
- if (!(subindex & 1))
- {
- std::stringstream ss;
- ss << (24 - 6 * subindex) << " dB";
- legend = ss.str();
- }
- vertical = false;
- return true;
-}
-
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
bool frequency_response_line_graph::get_gridline(int index, int subindex, float &pos, bool &vertical, std::string &legend, cairo_iface *context)
@@ -1811,131 +1730,114 @@ int gain_reduction_audio_module::get_changed_offsets(int generation, int &subind
/// of different chained filters.
///////////////////////////////////////////////////////////////////////////////////////////////
-equalizer12band_audio_module::equalizer12band_audio_module()
+template<class BaseClass>
+equalizerNband_audio_module<BaseClass>::equalizerNband_audio_module()
{
is_active = false;
srate = 0;
last_generation = 0;
- clip_inL = 0.f;
- clip_inR = 0.f;
- clip_outL = 0.f;
- clip_outR = 0.f;
- meter_inL = 0.f;
- meter_inR = 0.f;
- meter_outL = 0.f;
- meter_outR = 0.f;
+ clip_inL = clip_inR = clip_outL = clip_outR = 0.f;
+ meter_inL = meter_inR = meter_outL = meter_outR = 0.f;
}
-void equalizer12band_audio_module::activate()
+template<class BaseClass>
+void equalizerNband_audio_module<BaseClass>::activate()
{
is_active = true;
// set all filters
params_changed();
}
-void equalizer12band_audio_module::deactivate()
+
+template<class BaseClass>
+void equalizerNband_audio_module<BaseClass>::deactivate()
{
is_active = false;
}
-void equalizer12band_audio_module::params_changed()
+static inline void copy_lphp(biquad_d2<float> filters[3][2])
+{
+ for (int i = 0; i < 3; i++)
+ for (int j = 0; j < 2; j++)
+ if (i || j)
+ filters[i][j].copy_coeffs(filters[0][0]);
+}
+
+
+template<class BaseClass>
+void equalizerNband_audio_module<BaseClass>::params_changed()
{
// set the params of all filters
- if(*params[param_hp_freq] != hp_freq_old) {
- hpL[0].set_hp_rbj(*params[param_hp_freq], 0.707, (float)srate, 1.0);
- hpL[1].copy_coeffs(hpL[0]);
- hpL[2].copy_coeffs(hpL[0]);
- hpR[0].copy_coeffs(hpL[0]);
- hpR[1].copy_coeffs(hpL[0]);
- hpR[2].copy_coeffs(hpL[0]);
- hp_freq_old = *params[param_hp_freq];
- }
- if(*params[param_lp_freq] != lp_freq_old) {
- lpL[0].set_lp_rbj(*params[param_lp_freq], 0.707, (float)srate, 1.0);
- lpL[1].copy_coeffs(lpL[0]);
- lpL[2].copy_coeffs(lpL[0]);
- lpR[0].copy_coeffs(lpL[0]);
- lpR[1].copy_coeffs(lpL[0]);
- lpR[2].copy_coeffs(lpL[0]);
- lp_freq_old = *params[param_lp_freq];
+
+ // lp/hp first
+ float hpfreq = *params[AM::param_hp_freq], lpfreq = *params[AM::param_lp_freq];
+
+ if(hpfreq != hp_freq_old) {
+ hp[0][0].set_hp_rbj(hpfreq, 0.707, (float)srate, 1.0);
+ copy_lphp(hp);
+ hp_freq_old = hpfreq;
}
- if(*params[param_ls_freq] != ls_freq_old or *params[param_ls_level] != ls_level_old) {
- lsL.set_lowshelf_rbj(*params[param_ls_freq], 0.707, *params[param_ls_level], (float)srate);
+ if(lpfreq != lp_freq_old) {
+ lp[0][0].set_lp_rbj(lpfreq, 0.707, (float)srate, 1.0);
+ copy_lphp(lp);
+ lp_freq_old = lpfreq;
+ }
+
+ // then shelves
+ float hsfreq = *params[AM::param_hs_freq], hslevel = *params[AM::param_hs_level];
+ float lsfreq = *params[AM::param_ls_freq], lslevel = *params[AM::param_ls_level];
+
+ if(lsfreq != ls_freq_old or lslevel != ls_level_old) {
+ lsL.set_lowshelf_rbj(lsfreq, 0.707, lslevel, (float)srate);
lsR.copy_coeffs(lsL);
- ls_level_old = *params[param_ls_level];
- ls_freq_old = *params[param_ls_freq];
+ ls_level_old = lslevel;
+ ls_freq_old = lsfreq;
}
- if(*params[param_hs_freq] != hs_freq_old or *params[param_hs_level] != hs_level_old) {
- hsL.set_highshelf_rbj(*params[param_hs_freq], 0.707, *params[param_hs_level], (float)srate);
+ if(hsfreq != hs_freq_old or hslevel != hs_level_old) {
+ hsL.set_highshelf_rbj(hsfreq, 0.707, hslevel, (float)srate);
hsR.copy_coeffs(hsL);
- hs_level_old = *params[param_hs_level];
- hs_freq_old = *params[param_hs_freq];
- }
- if(*params[param_p1_freq] != p_freq_old[0] or *params[param_p1_level] != p_level_old[0] or *params[param_p1_q] != p_q_old[0]) {
- pL[0].set_peakeq_rbj((float)*params[param_p1_freq], *params[param_p1_q], *params[param_p1_level], (float)srate);
- pR[0].copy_coeffs(pL[0]);
- p_freq_old[0] = *params[param_p1_freq];
- p_level_old[0] = *params[param_p1_level];
- p_q_old[0] = *params[param_p1_q];
+ hs_level_old = hslevel;
+ hs_freq_old = hsfreq;
}
- if(*params[param_p2_freq] != p_freq_old[1] or *params[param_p2_level] != p_level_old[1] or *params[param_p2_q] != p_q_old[1]) {
- pL[1].set_peakeq_rbj((float)*params[param_p2_freq], *params[param_p2_q], *params[param_p2_level], (float)srate);
- pR[1].copy_coeffs(pL[1]);
- p_freq_old[1] = *params[param_p2_freq];
- p_level_old[1] = *params[param_p2_level];
- p_q_old[1] = *params[param_p2_q];
- }
- if(*params[param_p3_freq] != p_freq_old[2] or *params[param_p3_level] != p_level_old[2] or *params[param_p3_q] != p_q_old[2]) {
- pL[2].set_peakeq_rbj((float)*params[param_p3_freq], *params[param_p3_q], *params[param_p3_level], (float)srate);
- pR[2].copy_coeffs(pL[2]);
- p_freq_old[2] = *params[param_p3_freq];
- p_level_old[2] = *params[param_p3_level];
- p_q_old[2] = *params[param_p3_q];
+ for (int i = 0; i < AM::PeakBands; i++)
+ {
+ int offset = i * params_per_band;
+ float freq = *params[AM::param_p1_freq + offset];
+ float level = *params[AM::param_p1_level + offset];
+ float q = *params[AM::param_p1_q + offset];
+ if(freq != p_freq_old[i] or level != p_level_old[i] or q != p_q_old[i]) {
+ pL[i].set_peakeq_rbj(freq, q, level, (float)srate);
+ pR[i].copy_coeffs(pL[i]);
+ p_freq_old[i] = freq;
+ p_level_old[i] = level;
+ p_q_old[i] = q;
+ }
}
- if(*params[param_p4_freq] != p_freq_old[3] or *params[param_p4_level] != p_level_old[3] or *params[param_p4_q] != p_q_old[3]) {
- pL[3].set_peakeq_rbj((float)*params[param_p4_freq], *params[param_p4_q], *params[param_p4_level], (float)srate);
- pR[3].copy_coeffs(pL[3]);
- p_freq_old[3] = *params[param_p4_freq];
- p_level_old[3] = *params[param_p4_level];
- p_q_old[3] = *params[param_p4_q];
- }
- if(*params[param_p5_freq] != p_freq_old[4] or *params[param_p5_level] != p_level_old[4] or *params[param_p5_q] != p_q_old[4]) {
- pL[4].set_peakeq_rbj((float)*params[param_p5_freq], *params[param_p5_q], *params[param_p5_level], (float)srate);
- pR[4].copy_coeffs(pL[4]);
- p_freq_old[4] = *params[param_p5_freq];
- p_level_old[4] = *params[param_p5_level];
- p_q_old[4] = *params[param_p5_q];
- }
- if(*params[param_p6_freq] != p_freq_old[5] or *params[param_p6_level] != p_level_old[5] or *params[param_p6_q] != p_q_old[5]) {
- pL[5].set_peakeq_rbj((float)*params[param_p6_freq], *params[param_p6_q], *params[param_p6_level], (float)srate);
- pR[5].copy_coeffs(pL[5]);
- p_freq_old[5] = *params[param_p6_freq];
- p_level_old[5] = *params[param_p6_level];
- p_q_old[5] = *params[param_p6_q];
- }
- if(*params[param_p7_freq] != p_freq_old[6] or *params[param_p7_level] != p_level_old[6] or *params[param_p7_q] != p_q_old[6]) {
- pL[6].set_peakeq_rbj((float)*params[param_p7_freq], *params[param_p7_q], *params[param_p7_level], (float)srate);
- pR[6].copy_coeffs(pL[6]);
- p_freq_old[6] = *params[param_p7_freq];
- p_level_old[6] = *params[param_p7_level];
- p_q_old[6] = *params[param_p7_q];
- }
- if(*params[param_p8_freq] != p_freq_old[7] or *params[param_p8_level] != p_level_old[7] or *params[param_p8_q] != p_q_old[7]) {
- pL[7].set_peakeq_rbj((float)*params[param_p8_freq], *params[param_p8_q], *params[param_p8_level], (float)srate);
- pR[7].copy_coeffs(pL[7]);
- p_freq_old[7] = *params[param_p8_freq];
- p_level_old[7] = *params[param_p8_level];
- p_q_old[7] = *params[param_p8_q];
- }
-}
-
-void equalizer12band_audio_module::set_sample_rate(uint32_t sr)
+}
+
+static void process_hplp(float &procL, float &procR, dsp::biquad_d2<float> filter[3][2], CalfEqMode mode)
{
- srate = sr;
+ switch(mode) {
+ case MODE12DB:
+ procL = filter[0][0].process(procL);
+ procR = filter[0][1].process(procR);
+ break;
+ case MODE24DB:
+ procL = filter[1][0].process(filter[0][0].process(procL));
+ procR = filter[1][1].process(filter[0][1].process(procR));
+ break;
+ case MODE36DB:
+ procL = filter[2][0].process(filter[1][0].process(filter[0][0].process(procL)));
+ procR = filter[2][1].process(filter[1][1].process(filter[0][1].process(procR)));
+ break;
+ }
}
-uint32_t equalizer12band_audio_module::process(uint32_t offset, uint32_t numsamples, uint32_t inputs_mask, uint32_t outputs_mask)
+#define SET_IF_CONNECTED(param) if (params[AM::param_##param] != NULL) *params[AM::param_##param] = param;
+
+template<class BaseClass>
+uint32_t equalizerNband_audio_module<BaseClass>::process(uint32_t offset, uint32_t numsamples, uint32_t inputs_mask, uint32_t outputs_mask)
{
- bool bypass = *params[param_bypass] > 0.5f;
+ bool bypass = *params[AM::param_bypass] > 0.f;
numsamples += offset;
if(bypass) {
// everything bypassed
@@ -1945,14 +1847,8 @@ uint32_t equalizer12band_audio_module::process(uint32_t offset, uint32_t numsamp
++offset;
}
// displays, too
- clip_inL = 0.f;
- clip_inR = 0.f;
- clip_outL = 0.f;
- clip_outR = 0.f;
- meter_inL = 0.f;
- meter_inR = 0.f;
- meter_outL = 0.f;
- meter_outR = 0.f;
+ clip_inL = clip_inR = clip_outL = clip_outR = 0.f;
+ meter_inL = meter_inR = meter_outL = meter_outR = 0.f;
} else {
clip_inL -= std::min(clip_inL, numsamples);
@@ -1963,6 +1859,8 @@ uint32_t equalizer12band_audio_module::process(uint32_t offset, uint32_t numsamp
meter_inR = 0.f;
meter_outL = 0.f;
meter_outR = 0.f;
+ CalfEqMode hp_mode = (CalfEqMode)(int)*params[AM::param_hp_mode];
+ CalfEqMode lp_mode = (CalfEqMode)(int)*params[AM::param_lp_mode];
// process
while(offset < numsamples) {
@@ -1972,88 +1870,37 @@ uint32_t equalizer12band_audio_module::process(uint32_t offset, uint32_t numsamp
float inL = ins[0][offset];
float inR = ins[1][offset];
// in level
- inR *= *params[param_level_in];
- inL *= *params[param_level_in];
+ inR *= *params[AM::param_level_in];
+ inL *= *params[AM::param_level_in];
float procL = inL;
float procR = inR;
// all filters in chain
- if(*params[param_hp_active] > 0.f) {
- switch((int)*params[param_hp_mode]) {
- case MODE12DB:
- procL = hpL[0].process(procL);
- procR = hpR[0].process(procR);
- break;
- case MODE24DB:
- procL = hpL[1].process(hpL[0].process(procL));
- procR = hpR[1].process(hpR[0].process(procR));
- break;
- case MODE36DB:
- procL = hpL[2].process(hpL[1].process(hpL[0].process(procL)));
- procR = hpR[2].process(hpR[1].process(hpR[0].process(procR)));
- break;
- }
+ if(*params[AM::param_hp_active] > 0.f) {
+ process_hplp(procL, procR, hp, hp_mode);
}
- if(*params[param_lp_active] > 0.f) {
- switch((int)*params[param_lp_mode]) {
- case MODE12DB:
- procL = lpL[0].process(procL);
- procR = lpR[0].process(procR);
- break;
- case MODE24DB:
- procL = lpL[1].process(lpL[0].process(procL));
- procR = lpR[1].process(lpR[0].process(procR));
- break;
- case MODE36DB:
- procL = lpL[2].process(lpL[1].process(lpL[0].process(procL)));
- procR = lpR[2].process(lpR[1].process(lpR[0].process(procR)));
- break;
- }
+ if(*params[AM::param_lp_active] > 0.f) {
+ process_hplp(procL, procR, lp, lp_mode);
}
- if(*params[param_ls_active] > 0.f) {
+ if(*params[AM::param_ls_active] > 0.f) {
procL = lsL.process(procL);
procR = lsR.process(procR);
}
- if(*params[param_hs_active] > 0.f) {
+ if(*params[AM::param_hs_active] > 0.f) {
procL = hsL.process(procL);
procR = hsR.process(procR);
}
- if(*params[param_p1_active] > 0.f) {
- procL = pL[0].process(procL);
- procR = pR[0].process(procR);
- }
- if(*params[param_p2_active] > 0.f) {
- procL = pL[1].process(procL);
- procR = pR[1].process(procR);
- }
- if(*params[param_p3_active] > 0.f) {
- procL = pL[2].process(procL);
- procR = pR[2].process(procR);
- }
- if(*params[param_p4_active] > 0.f) {
- procL = pL[3].process(procL);
- procR = pR[3].process(procR);
- }
- if(*params[param_p5_active] > 0.f) {
- procL = pL[4].process(procL);
- procR = pR[4].process(procR);
- }
- if(*params[param_p6_active] > 0.f) {
- procL = pL[5].process(procL);
- procR = pR[5].process(procR);
- }
- if(*params[param_p7_active] > 0.f) {
- procL = pL[6].process(procL);
- procR = pR[6].process(procR);
- }
- if(*params[param_p8_active] > 0.f) {
- procL = pL[7].process(procL);
- procR = pR[7].process(procR);
+ for (int i = 0; i < AM::PeakBands; i++)
+ {
+ if(*params[AM::param_p1_active + i * params_per_band] > 0.f) {
+ procL = pL[i].process(procL);
+ procR = pR[i].process(procR);
+ }
}
- outL = procL * *params[param_level_out];
- outR = procR * *params[param_level_out];
+ outL = procL * *params[AM::param_level_out];
+ outR = procR * *params[AM::param_level_out];
// send to output
outs[0][offset] = outL;
@@ -2091,59 +1938,47 @@ uint32_t equalizer12band_audio_module::process(uint32_t offset, uint32_t numsamp
} // cycle trough samples
// clean up
for(int i = 0; i < 3; ++i) {
- hpL[i].sanitize();
- hpR[i].sanitize();
- lpL[i].sanitize();
- lpR[i].sanitize();
+ hp[i][0].sanitize();
+ hp[i][1].sanitize();
+ lp[i][0].sanitize();
+ lp[i][1].sanitize();
}
lsL.sanitize();
hsR.sanitize();
- for(int i = 0; i < 8; ++i) {
+ for(int i = 0; i < AM::PeakBands; ++i) {
pL[i].sanitize();
pR[i].sanitize();
}
}
// draw meters
- if(params[param_clip_inL] != NULL) {
- *params[param_clip_inL] = clip_inL;
- }
- if(params[param_clip_inR] != NULL) {
- *params[param_clip_inR] = clip_inR;
- }
- if(params[param_clip_outL] != NULL) {
- *params[param_clip_outL] = clip_outL;
- }
- if(params[param_clip_outR] != NULL) {
- *params[param_clip_outR] = clip_outR;
- }
-
- if(params[param_meter_inL] != NULL) {
- *params[param_meter_inL] = meter_inL;
- }
- if(params[param_meter_inR] != NULL) {
- *params[param_meter_inR] = meter_inR;
- }
- if(params[param_meter_outL] != NULL) {
- *params[param_meter_outL] = meter_outL;
- }
- if(params[param_meter_outR] != NULL) {
- *params[param_meter_outR] = meter_outR;
- }
+ SET_IF_CONNECTED(clip_inL)
+ SET_IF_CONNECTED(clip_inR)
+ SET_IF_CONNECTED(clip_outL)
+ SET_IF_CONNECTED(clip_outR)
+ SET_IF_CONNECTED(meter_inL)
+ SET_IF_CONNECTED(meter_inR)
+ SET_IF_CONNECTED(meter_outL)
+ SET_IF_CONNECTED(meter_outR)
// whatever has to be returned x)
return outputs_mask;
}
-bool equalizer12band_audio_module::get_graph(int index, int subindex, float *data, int points, cairo_iface *context)
+
+#undef SET_IF_CONNECTED
+
+template<class BaseClass>
+bool equalizerNband_audio_module<BaseClass>::get_graph(int index, int subindex, float *data, int points, cairo_iface *context)
{
if (!is_active)
return false;
- if (index == param_p1_freq && !subindex) {
+ if (index == AM::param_p1_freq && !subindex) {
context->set_line_width(1.5);
return ::get_graph(*this, subindex, data, points);
}
return false;
}
-bool equalizer12band_audio_module::get_gridline(int index, int subindex, float &pos, bool &vertical, std::string &legend, cairo_iface *context)
+template<class BaseClass>
+bool equalizerNband_audio_module<BaseClass>::get_gridline(int index, int subindex, float &pos, bool &vertical, std::string &legend, cairo_iface *context)
{
if (!is_active) {
return false;
@@ -2152,95 +1987,22 @@ bool equalizer12band_audio_module::get_gridline(int index, int subindex, float &
}
}
-int equalizer12band_audio_module::get_changed_offsets(int index, int generation, int &subindex_graph, int &subindex_dot, int &subindex_gridline)
+template<class BaseClass>
+int equalizerNband_audio_module<BaseClass>::get_changed_offsets(int index, int generation, int &subindex_graph, int &subindex_dot, int &subindex_gridline)
{
if (!is_active) {
return false;
} else {
- if (*params[param_hp_freq] != hp_freq_old1
- or *params[param_hp_mode] != hp_mode_old1
- or *params[param_lp_freq] != lp_freq_old1
- or *params[param_lp_mode] != lp_mode_old1
-
- or *params[param_ls_freq] != ls_freq_old1
- or *params[param_ls_level] != ls_level_old1
- or *params[param_hs_freq] != hs_freq_old1
- or *params[param_hs_level] != hs_level_old1
-
- or *params[param_p1_freq] != p_freq_old1[0]
- or *params[param_p1_level] != p_level_old1[0]
- or *params[param_p1_q] != p_q_old1[0]
-
- or *params[param_p2_freq] != p_freq_old1[1]
- or *params[param_p2_level] != p_level_old1[1]
- or *params[param_p2_q] != p_q_old1[1]
-
- or *params[param_p3_freq] != p_freq_old1[2]
- or *params[param_p3_level] != p_level_old1[2]
- or *params[param_p3_q] != p_q_old1[2]
-
- or *params[param_p4_freq] != p_freq_old1[3]
- or *params[param_p4_level] != p_level_old1[3]
- or *params[param_p4_q] != p_q_old1[3]
-
- or *params[param_p5_freq] != p_freq_old1[4]
- or *params[param_p5_level] != p_level_old1[4]
- or *params[param_p5_q] != p_q_old1[4]
-
- or *params[param_p6_freq] != p_freq_old1[5]
- or *params[param_p6_level] != p_level_old1[5]
- or *params[param_p6_q] != p_q_old1[5]
-
- or *params[param_p7_freq] != p_freq_old1[6]
- or *params[param_p7_level] != p_level_old1[6]
- or *params[param_p7_q] != p_q_old1[6]
-
- or *params[param_p8_freq] != p_freq_old1[7]
- or *params[param_p8_level] != p_level_old1[7]
- or *params[param_p8_q] != p_q_old1[7])
+ bool changed = false;
+ for (int i = 0; i < graph_param_count && !changed; i++)
{
-
- hp_freq_old1 = *params[param_hp_freq];
- hp_mode_old1 = *params[param_hp_mode];
- lp_freq_old1 = *params[param_lp_freq];
- lp_mode_old1 = *params[param_lp_mode];
-
- ls_freq_old1 = *params[param_ls_freq];
- ls_level_old1 = *params[param_ls_level];
- hs_freq_old1 = *params[param_hs_freq];
- hs_level_old1 = *params[param_hs_level];
-
- p_freq_old1[0] = *params[param_p1_freq];
- p_level_old1[0] = *params[param_p1_level];
- p_q_old1[0] = *params[param_p1_q];
-
- p_freq_old1[1] = *params[param_p2_freq];
- p_level_old1[1] = *params[param_p2_level];
- p_q_old1[1] = *params[param_p2_q];
-
- p_freq_old1[2] = *params[param_p3_freq];
- p_level_old1[2] = *params[param_p3_level];
- p_q_old1[2] = *params[param_p3_q];
-
- p_freq_old1[3] = *params[param_p4_freq];
- p_level_old1[3] = *params[param_p4_level];
- p_q_old1[3] = *params[param_p4_q];
-
- p_freq_old1[4] = *params[param_p5_freq];
- p_level_old1[4] = *params[param_p5_level];
- p_q_old1[4] = *params[param_p5_q];
-
- p_freq_old1[5] = *params[param_p6_freq];
- p_level_old1[5] = *params[param_p6_level];
- p_q_old1[5] = *params[param_p6_q];
-
- p_freq_old1[6] = *params[param_p7_freq];
- p_level_old1[6] = *params[param_p7_level];
- p_q_old1[6] = *params[param_p7_q];
-
- p_freq_old1[7] = *params[param_p8_freq];
- p_level_old1[7] = *params[param_p8_level];
- p_q_old1[7] = *params[param_p8_q];
+ if (*params[AM::first_graph_param + i] != old_params_for_graph[i])
+ changed = true;
+ }
+ if (changed)
+ {
+ for (int i = 0; i < graph_param_count; i++)
+ old_params_for_graph[i] = *params[AM::first_graph_param + i];
last_generation++;
subindex_graph = 0;
@@ -2258,382 +2020,37 @@ int equalizer12band_audio_module::get_changed_offsets(int index, int generation,
return false;
}
-/// Equalizer 8 Band by Markus Schmidt
-///
-/// This module is based on Krzysztof's filters. It provides a couple
-/// of different chained filters.
-///////////////////////////////////////////////////////////////////////////////////////////////
-
-equalizer8band_audio_module::equalizer8band_audio_module()
-{
- is_active = false;
- srate = 0;
- last_generation = 0;
- clip_inL = 0.f;
- clip_inR = 0.f;
- clip_outL = 0.f;
- clip_outR = 0.f;
- meter_inL = 0.f;
- meter_inR = 0.f;
- meter_outL = 0.f;
- meter_outR = 0.f;
-}
-
-void equalizer8band_audio_module::activate()
-{
- is_active = true;
- // set all filters
- params_changed();
-}
-void equalizer8band_audio_module::deactivate()
-{
- is_active = false;
-}
-
-void equalizer8band_audio_module::params_changed()
-{
- // set the params of all filters
- if(*params[param_hp_freq] != hp_freq_old) {
- hpL[0].set_hp_rbj(*params[param_hp_freq], 0.707, (float)srate, 1.0);
- hpL[1].copy_coeffs(hpL[0]);
- hpL[2].copy_coeffs(hpL[0]);
- hpR[0].copy_coeffs(hpL[0]);
- hpR[1].copy_coeffs(hpL[0]);
- hpR[2].copy_coeffs(hpL[0]);
- hp_freq_old = *params[param_hp_freq];
- }
- if(*params[param_lp_freq] != lp_freq_old) {
- lpL[0].set_lp_rbj(*params[param_lp_freq], 0.707, (float)srate, 1.0);
- lpL[1].copy_coeffs(lpL[0]);
- lpL[2].copy_coeffs(lpL[0]);
- lpR[0].copy_coeffs(lpL[0]);
- lpR[1].copy_coeffs(lpL[0]);
- lpR[2].copy_coeffs(lpL[0]);
- lp_freq_old = *params[param_lp_freq];
- }
- if(*params[param_ls_freq] != ls_freq_old or *params[param_ls_level] != ls_level_old) {
- lsL.set_lowshelf_rbj(*params[param_ls_freq], 0.707, *params[param_ls_level], (float)srate);
- lsR.copy_coeffs(lsL);
- ls_level_old = *params[param_ls_level];
- ls_freq_old = *params[param_ls_freq];
- }
- if(*params[param_hs_freq] != hs_freq_old or *params[param_hs_level] != hs_level_old) {
- hsL.set_highshelf_rbj(*params[param_hs_freq], 0.707, *params[param_hs_level], (float)srate);
- hsR.copy_coeffs(hsL);
- hs_level_old = *params[param_hs_level];
- hs_freq_old = *params[param_hs_freq];
- }
- if(*params[param_p1_freq] != p_freq_old[0] or *params[param_p1_level] != p_level_old[0] or *params[param_p1_q] != p_q_old[0]) {
- pL[0].set_peakeq_rbj((float)*params[param_p1_freq], *params[param_p1_q], *params[param_p1_level], (float)srate);
- pR[0].copy_coeffs(pL[0]);
- p_freq_old[0] = *params[param_p1_freq];
- p_level_old[0] = *params[param_p1_level];
- p_q_old[0] = *params[param_p1_q];
- }
- if(*params[param_p2_freq] != p_freq_old[1] or *params[param_p2_level] != p_level_old[1] or *params[param_p2_q] != p_q_old[1]) {
- pL[1].set_peakeq_rbj((float)*params[param_p2_freq], *params[param_p2_q], *params[param_p2_level], (float)srate);
- pR[1].copy_coeffs(pL[1]);
- p_freq_old[1] = *params[param_p2_freq];
- p_level_old[1] = *params[param_p2_level];
- p_q_old[1] = *params[param_p2_q];
- }
- if(*params[param_p3_freq] != p_freq_old[2] or *params[param_p3_level] != p_level_old[2] or *params[param_p3_q] != p_q_old[2]) {
- pL[2].set_peakeq_rbj((float)*params[param_p3_freq], *params[param_p3_q], *params[param_p3_level], (float)srate);
- pR[2].copy_coeffs(pL[2]);
- p_freq_old[2] = *params[param_p3_freq];
- p_level_old[2] = *params[param_p3_level];
- p_q_old[2] = *params[param_p3_q];
- }
- if(*params[param_p4_freq] != p_freq_old[3] or *params[param_p4_level] != p_level_old[3] or *params[param_p4_q] != p_q_old[3]) {
- pL[3].set_peakeq_rbj((float)*params[param_p4_freq], *params[param_p4_q], *params[param_p4_level], (float)srate);
- pR[3].copy_coeffs(pL[3]);
- p_freq_old[3] = *params[param_p4_freq];
- p_level_old[3] = *params[param_p4_level];
- p_q_old[3] = *params[param_p4_q];
- }
-}
-
-void equalizer8band_audio_module::set_sample_rate(uint32_t sr)
+static inline float adjusted_lphp_gain(float **params, int param_active, int param_mode, biquad_d2<float> filter, float freq, float srate)
{
- srate = sr;
-}
-
-uint32_t equalizer8band_audio_module::process(uint32_t offset, uint32_t numsamples, uint32_t inputs_mask, uint32_t outputs_mask)
-{
- bool bypass = *params[param_bypass] > 0.5f;
- numsamples += offset;
- if(bypass) {
- // everything bypassed
- while(offset < numsamples) {
- outs[0][offset] = ins[0][offset];
- outs[1][offset] = ins[1][offset];
- ++offset;
+ if(*params[param_active] > 0.f) {
+ float gain = filter.freq_gain(freq, srate);
+ switch((int)*params[param_mode]) {
+ case MODE12DB:
+ return gain;
+ case MODE24DB:
+ return gain * gain;
+ case MODE36DB:
+ return gain * gain * gain;
}
- // displays, too
- clip_inL = 0.f;
- clip_inR = 0.f;
- clip_outL = 0.f;
- clip_outR = 0.f;
- meter_inL = 0.f;
- meter_inR = 0.f;
- meter_outL = 0.f;
- meter_outR = 0.f;
- } else {
-
- clip_inL -= std::min(clip_inL, numsamples);
- clip_inR -= std::min(clip_inR, numsamples);
- clip_outL -= std::min(clip_outL, numsamples);
- clip_outR -= std::min(clip_outR, numsamples);
- meter_inL = 0.f;
- meter_inR = 0.f;
- meter_outL = 0.f;
- meter_outR = 0.f;
-
- // process
- while(offset < numsamples) {
- // cycle through samples
- float outL = 0.f;
- float outR = 0.f;
- float inL = ins[0][offset];
- float inR = ins[1][offset];
- // in level
- inR *= *params[param_level_in];
- inL *= *params[param_level_in];
-
- float procL = inL;
- float procR = inR;
-
- // all filters in chain
- if(*params[param_hp_active] > 0.f) {
- switch((int)*params[param_hp_mode]) {
- case MODE12DB:
- procL = hpL[0].process(procL);
- procR = hpR[0].process(procR);
- break;
- case MODE24DB:
- procL = hpL[1].process(hpL[0].process(procL));
- procR = hpR[1].process(hpR[0].process(procR));
- break;
- case MODE36DB:
- procL = hpL[2].process(hpL[1].process(hpL[0].process(procL)));
- procR = hpR[2].process(hpR[1].process(hpR[0].process(procR)));
- break;
- }
- }
- if(*params[param_lp_active] > 0.f) {
- switch((int)*params[param_lp_mode]) {
- case MODE12DB:
- procL = lpL[0].process(procL);
- procR = lpR[0].process(procR);
- break;
- case MODE24DB:
- procL = lpL[1].process(lpL[0].process(procL));
- procR = lpR[1].process(lpR[0].process(procR));
- break;
- case MODE36DB:
- procL = lpL[2].process(lpL[1].process(lpL[0].process(procL)));
- procR = lpR[2].process(lpR[1].process(lpR[0].process(procR)));
- break;
- }
- }
- if(*params[param_ls_active] > 0.f) {
- procL = lsL.process(procL);
- procR = lsR.process(procR);
- }
- if(*params[param_hs_active] > 0.f) {
- procL = hsL.process(procL);
- procR = hsR.process(procR);
- }
- if(*params[param_p1_active] > 0.f) {
- procL = pL[0].process(procL);
- procR = pR[0].process(procR);
- }
- if(*params[param_p2_active] > 0.f) {
- procL = pL[1].process(procL);
- procR = pR[1].process(procR);
- }
- if(*params[param_p3_active] > 0.f) {
- procL = pL[2].process(procL);
- procR = pR[2].process(procR);
- }
- if(*params[param_p4_active] > 0.f) {
- procL = pL[3].process(procL);
- procR = pR[3].process(procR);
- }
-
- outL = procL * *params[param_level_out];
- outR = procR * *params[param_level_out];
-
- // send to output
- outs[0][offset] = outL;
- outs[1][offset] = outR;
-
- // clip LED's
- if(inL > 1.f) {
- clip_inL = srate >> 3;
- }
- if(inR > 1.f) {
- clip_inR = srate >> 3;
- }
- if(outL > 1.f) {
- clip_outL = srate >> 3;
- }
- if(outR > 1.f) {
- clip_outR = srate >> 3;
- }
- // set up in / out meters
- if(inL > meter_inL) {
- meter_inL = inL;
- }
- if(inR > meter_inR) {
- meter_inR = inR;
- }
- if(outL > meter_outL) {
- meter_outL = outL;
- }
- if(outR > meter_outR) {
- meter_outR = outR;
- }
-
- // next sample
- ++offset;
- } // cycle trough samples
- // clean up
- for(int i = 0; i < 3; ++i) {
- hpL[i].sanitize();
- hpR[i].sanitize();
- lpL[i].sanitize();
- lpR[i].sanitize();
- }
- lsL.sanitize();
- hsR.sanitize();
- for(int i = 0; i < 4; ++i) {
- pL[i].sanitize();
- pR[i].sanitize();
- }
- }
- // draw meters
- if(params[param_clip_inL] != NULL) {
- *params[param_clip_inL] = clip_inL;
- }
- if(params[param_clip_inR] != NULL) {
- *params[param_clip_inR] = clip_inR;
- }
- if(params[param_clip_outL] != NULL) {
- *params[param_clip_outL] = clip_outL;
}
- if(params[param_clip_outR] != NULL) {
- *params[param_clip_outR] = clip_outR;
- }
-
- if(params[param_meter_inL] != NULL) {
- *params[param_meter_inL] = meter_inL;
- }
- if(params[param_meter_inR] != NULL) {
- *params[param_meter_inR] = meter_inR;
- }
- if(params[param_meter_outL] != NULL) {
- *params[param_meter_outL] = meter_outL;
- }
- if(params[param_meter_outR] != NULL) {
- *params[param_meter_outR] = meter_outR;
- }
- // whatever has to be returned x)
- return outputs_mask;
-}
-bool equalizer8band_audio_module::get_graph(int index, int subindex, float *data, int points, cairo_iface *context)
-{
- if (!is_active)
- return false;
- if (index == param_p1_freq && !subindex) {
- context->set_line_width(1.5);
- return ::get_graph(*this, subindex, data, points);
- }
- return false;
+ return 1;
}
-bool equalizer8band_audio_module::get_gridline(int index, int subindex, float &pos, bool &vertical, std::string &legend, cairo_iface *context)
+template<class BaseClass>
+float equalizerNband_audio_module<BaseClass>::freq_gain(int index, double freq, uint32_t sr)
{
- if (!is_active) {
- return false;
- } else {
- return get_freq_gridline(subindex, pos, vertical, legend, context);
- }
+ float ret = 1.f;
+ ret *= adjusted_lphp_gain(params, AM::param_hp_active, AM::param_hp_mode, hp[0][0], freq, (float)sr);
+ ret *= adjusted_lphp_gain(params, AM::param_lp_active, AM::param_lp_mode, lp[0][0], freq, (float)sr);
+ ret *= (*params[AM::param_ls_active] > 0.f) ? lsL.freq_gain(freq, sr) : 1;
+ ret *= (*params[AM::param_hs_active] > 0.f) ? hsL.freq_gain(freq, sr) : 1;
+ for (int i = 0; i < PeakBands; i++)
+ ret *= (*params[AM::param_p1_active + i * params_per_band] > 0.f) ? pL[i].freq_gain(freq, (float)sr) : 1;
+ return ret;
}
-int equalizer8band_audio_module::get_changed_offsets(int index, int generation, int &subindex_graph, int &subindex_dot, int &subindex_gridline)
-{
- if (!is_active) {
- return false;
- } else {
- if (*params[param_hp_freq] != hp_freq_old1
- or *params[param_hp_mode] != hp_mode_old1
- or *params[param_lp_freq] != lp_freq_old1
- or *params[param_lp_mode] != lp_mode_old1
-
- or *params[param_ls_freq] != ls_freq_old1
- or *params[param_ls_level] != ls_level_old1
- or *params[param_hs_freq] != hs_freq_old1
- or *params[param_hs_level] != hs_level_old1
-
- or *params[param_p1_freq] != p_freq_old1[0]
- or *params[param_p1_level] != p_level_old1[0]
- or *params[param_p1_q] != p_q_old1[0]
-
- or *params[param_p2_freq] != p_freq_old1[1]
- or *params[param_p2_level] != p_level_old1[1]
- or *params[param_p2_q] != p_q_old1[1]
-
- or *params[param_p3_freq] != p_freq_old1[2]
- or *params[param_p3_level] != p_level_old1[2]
- or *params[param_p3_q] != p_q_old1[2]
-
- or *params[param_p4_freq] != p_freq_old1[3]
- or *params[param_p4_level] != p_level_old1[3]
- or *params[param_p4_q] != p_q_old1[3])
- {
-
- hp_freq_old1 = *params[param_hp_freq];
- hp_mode_old1 = *params[param_hp_mode];
- lp_freq_old1 = *params[param_lp_freq];
- lp_mode_old1 = *params[param_lp_mode];
-
- ls_freq_old1 = *params[param_ls_freq];
- ls_level_old1 = *params[param_ls_level];
- hs_freq_old1 = *params[param_hs_freq];
- hs_level_old1 = *params[param_hs_level];
-
- p_freq_old1[0] = *params[param_p1_freq];
- p_level_old1[0] = *params[param_p1_level];
- p_q_old1[0] = *params[param_p1_q];
-
- p_freq_old1[1] = *params[param_p2_freq];
- p_level_old1[1] = *params[param_p2_level];
- p_q_old1[1] = *params[param_p2_q];
-
- p_freq_old1[2] = *params[param_p3_freq];
- p_level_old1[2] = *params[param_p3_level];
- p_q_old1[2] = *params[param_p3_q];
-
- p_freq_old1[3] = *params[param_p4_freq];
- p_level_old1[3] = *params[param_p4_level];
- p_q_old1[3] = *params[param_p4_q];
-
- last_generation++;
- subindex_graph = 0;
- subindex_dot = INT_MAX;
- subindex_gridline = INT_MAX;
- }
- else {
- subindex_graph = 0;
- subindex_dot = subindex_gridline = generation ? INT_MAX : 0;
- }
- if (generation == last_calculated_generation)
- subindex_graph = INT_MAX;
- return last_generation;
- }
- return false;
-}
+template class equalizerNband_audio_module<equalizer8band_metadata>;
+template class equalizerNband_audio_module<equalizer12band_metadata>;
/// Equalizer 5 Band by Markus Schmidt
///
--
calf audio plugins packaging
More information about the pkg-multimedia-commits
mailing list