torvalds-GuitarPedal/Effects/cabsim.h

// NAME: Cab Sim [CAB]
// PRIORITY: 129
// POT: "Resonance" LINEAR(0 1) = 0.5
// POT: "Presence" LINEAR(0 1) = 0.5
// POT: "Axis" LINEAR(0 1) = 0.5
// POT: "Breakup" LINEAR(0 1) = 0.0
// POT: "Chug" LINEAR(0 1) = 0.0
//
// ====================================================================
// WARNING: VERY APPROXIMATE SPEAKER EMULATION!
// ====================================================================
// This is NOT an Impulse Response (IR) loader or an exact physical
// model of a speaker cone. 
//
// It is a rough IIR approximation of a classic 12-inch guitar speaker
// in a closed-back cabinet (e.g. Celestion Vintage 30) using cascaded
// biquad filters. It aims to cut the nasty "fizz" of amp distortion
// so it sounds passable through full-range studio monitors or USB
// audio, by mimicking the steep mechanical high-frequency roll-off
// and the low-end impedance bump of a real cab.
// ====================================================================

struct {
	struct biquad low_cut;     // 75 Hz HPF (speaker physical limit)
	struct biquad thump_bp;    // ~110 Hz parallel bandpass for dynamic resonance
	struct biquad scoop;       // ~400 Hz peaking (mid scoop)
	struct biquad presence;    // ~2.5 kHz peaking (speaker bite)
	struct biquad hi_cut_1;    // 1st half of 24dB/oct LPF
	struct biquad hi_cut_2;    // 2nd half of 24dB/oct LPF

	struct envelope chug_env;  // Envelope follower for low-frequency energy
	struct single_pole_state env_lp;
	struct single_pole_coeff env_coeff;
	float res_gain;            // Calculated linear gain for resonance
	float breakup_amt;
	float chug_amt;
} cab;

static inline void cab_init(unsigned char pot[10])
{
	float res_pot = cab_resonance_pot(pot);
	float pres_pot = cab_presence_pot(pot);
	float axis_pot = cab_axis_pot(pot);
	cab.breakup_amt = cab_breakup_pot(pot);
	cab.chug_amt = cab_chug_pot(pot);

	// Calculate base resonance gain. db_to_level expects voltage gain.
	// Since we are using a parallel bandpass now, we just multiply the bandpass
	// output by (A - 1) to get the equivalent peaking boost.
	// 0 to +8dB. Amplitude A = 10^(dB/20).
	float res_db = res_pot * 8.0f;
	float res_A = db_to_level(res_db);
	cab.res_gain = res_A - 1.0f;
	if (cab.res_gain < 0.0f) cab.res_gain = 0.0f;

	// High cut frequency sweeps from ~3500 Hz (off-axis/dark) to ~6000 Hz (on-axis/bright)
	float hicut_freq = 3500.0f + axis_pot * 2500.0f;

	// Envelope for chug compression (fast attack, medium release)
	envelope_init(&cab.chug_env, 2.0f, 100.0f);
	cab.env_coeff = single_pole_freq(150.0f); // Lowpass for envelope tracking

	// 1. Low-end roll-off (12dB/octave HPF)
	biquad_hpf(&cab.low_cut, 75.0f, 0.7f);

	// 2. Cabinet Resonance thump (~110Hz) - Now a parallel bandpass
	biquad_bpf(&cab.thump_bp, 110.0f, 1.5f);

	// 3. Natural paper cone mid scoop (~400Hz, fixed -3dB)
	biquad_peaking(&cab.scoop, 400.0f, 1.0f, db_to_A(-3.0f));

	// 4. Upper-mid bite (~2500Hz), 0 to +6dB
	biquad_peaking(&cab.presence, 2500.0f, 1.5f, db_to_A(pres_pot * 6.0f));

	// 5. Steep 24dB/octave high-end roll-off (two cascaded 12dB/oct LPFs)
	// A simple Q=0.7 on both gives a decent 4th-order slope.
	biquad_lpf(&cab.hi_cut_1, hicut_freq, 0.7f);
	biquad_lpf(&cab.hi_cut_2, hicut_freq, 0.7f);
}

static inline float cab_step(float in)
{
	float out = in;

	// 1. Extract low-frequency envelope for Chug compressor
	float low_energy = single_pole_lpf(out, &cab.env_lp, cab.env_coeff);
	float env = envelope_step(&cab.chug_env, low_energy);

	// 2. Low-cut
	out = biquad_step(&cab.low_cut, out);

	// 3. Cone Breakup (Saturation)
	// We do this BEFORE the massive 110Hz thump to prevent Intermodulation Distortion (IMD).
	// If you boost bass before clipping, the bass frequencies modulate the high frequencies
	// and turn chords into indistinguishable mud.
	if (cab.breakup_amt > 0.0f) {
		float drive_gain = 1.0f + cab.breakup_amt * 40.0f;
		float driven = out * drive_gain;
		float clipped = tanhf(driven + 0.2f) - 0.197375f;
		out = clipped / (drive_gain * 0.961f);
	}

	// 4. Dynamic Thump (parallel bandpass)
	float thump_sig = biquad_step(&cab.thump_bp, out);
	// Chug amount determines how much the envelope reduces the resonance.
	// Since guitar signals are typically ~0.1 peak, the envelope is very small.
	// We multiply the envelope by 25.0 to scale it into a useful compression range.
	float compression = 1.0f - (env * 25.0f * cab.chug_amt);
	if (compression < 0.0f) compression = 0.0f;
	out += thump_sig * (cab.res_gain * compression);

	// 5. Scoop
	out = biquad_step(&cab.scoop, out);

	// 6. Presence & High Cut
	out = biquad_step(&cab.presence, out);
	out = biquad_step(&cab.hi_cut_1, out);
	out = biquad_step(&cab.hi_cut_2, out);

	return out;
}