Ripple.txt

desc:Ripple Phaser (by Geraint Luff)

in_pin:Left
in_pin:Right
out_pin:Left
out_pin:Right

slider1:control_band_count=4<2,20,1>-Number of bands
slider2:low_freq=100<30,2000>-Low freq
slider3:high_freq=12000<1000,20480>-High freq
slider4:cycle_phase_offset=0<0,1>-Phase Offset
slider5:cycle_phase_stereo_offset=0<-0.5,0.5>-Stereo Offset
slider6:cycle_phase_lfo_hz=0<-10,10>-Phase LFO (hz)
slider7:cycle_phase_invbeat=0.5<-4,4,0.5>-Phase LFO (/beat)
slider8:control_filter_mode=0<0,1,1{notch,peak}>-Filter type
slider9:filter_db=60<0,60,0.1>-Filter strength (dB)
slider10:filter_width_factor=0.7<0.01,0.7>-Filter width
slider11:output_gain_db=0<-12,6>-Output (db)

import ui-lib.jsfx-inc
import filter-utils.jsfx-inc
import frequency-graph.jsfx-inc

@init

MAX_BAND_COUNT = 20 + 5;

freemem = ui_setup(0);
freemem = (filter_mem_l = freemem) + FILTER#*MAX_BAND_COUNT;
freemem = (filter_mem_r = freemem) + FILTER#*MAX_BAND_COUNT;

phase_logger_length = ceil(srate*1/(samplesblock ? samplesblock : 256));
freemem = (phase_logger_buffer = freemem) + phase_logger_length;

g_buffer_length = 1024;
freemem = (g_buffer = freemem) + g_buffer_length;

/********* Translate between memory and filter-bank *********/

function single_filter_to_mem(mem_i, filter*) (
	mem_i[FILTER#A1] = filter.a1;
	mem_i[FILTER#A1_STEP] = filter.a1_step;
	mem_i[FILTER#A2] = filter.a2;
	mem_i[FILTER#A2_STEP] = filter.a2_step;
	mem_i[FILTER#B0] = filter.b0;
	mem_i[FILTER#B0_STEP] = filter.b0_step;
	mem_i[FILTER#B1] = filter.b1;
	mem_i[FILTER#B1_STEP] = filter.b1_step;
	mem_i[FILTER#B2] = filter.b2;
	mem_i[FILTER#B2_STEP] = filter.b2_step;
	mem_i[FILTER#X1] = filter.x1;
	mem_i[FILTER#X2] = filter.x2;
	mem_i[FILTER#Y1] = filter.y1;
	mem_i[FILTER#Y2] = filter.y2;
);

function filters_to_mem(mem, bank*) local(mem_i) (
	mem_i = mem;
	bank.bank16_enabled ? (
		{#NUM=0,15}
		single_filter_to_mem(mem_i, bank.bank16_NUM);
		mem_i += FILTER#;
		{#}
	);
	bank.bank8_enabled ? (
		{#NUM=0,7}
		single_filter_to_mem(mem_i, bank.bank8_NUM);
		mem_i += FILTER#;
		{#}
	);
	bank.bank4_enabled ? (
		{#NUM=0,3}
		single_filter_to_mem(mem_i, bank.bank4_NUM);
		mem_i += FILTER#;
		{#}
	);
	bank.bank2_enabled ? (
		{#NUM=0,1}
		single_filter_to_mem(mem_i, bank.bank2_NUM);
		mem_i += FILTER#;
		{#}
	);
	bank.bank1_enabled ? (
		single_filter_to_mem(mem_i, bank.bank1_0);
		mem_i += FILTER#;
	);
);

function single_filter_to_bank(mem_i, filter*) (
	filter.a1 = mem_i[FILTER#A1];
	filter.a1_step = mem_i[FILTER#A1_STEP];
	filter.a2 = mem_i[FILTER#A2];
	filter.a2_step = mem_i[FILTER#A2_STEP];
	filter.b0 = mem_i[FILTER#B0];
	filter.b0_step = mem_i[FILTER#B0_STEP];
	filter.b1 = mem_i[FILTER#B1];
	filter.b1_step = mem_i[FILTER#B1_STEP];
	filter.b2 = mem_i[FILTER#B2];
	filter.b2_step = mem_i[FILTER#B2_STEP];
	filter.x1 = mem_i[FILTER#X1];
	filter.x2 = mem_i[FILTER#X2];
	filter.y1 = mem_i[FILTER#Y1];
	filter.y2 = mem_i[FILTER#Y2];
);

function filters_to_bank(mem, bank*) local(i, mem_i) (
	bank.bank16_enabled = actual_band_count&16;
	bank.bank8_enabled = actual_band_count&8;
	bank.bank4_enabled = actual_band_count&4;
	bank.bank2_enabled = actual_band_count&2;
	bank.bank1_enabled = actual_band_count&1;

	mem_i = mem;
	bank.bank16_enabled ? (
		{#NUM=0,15}
		single_filter_to_bank(mem_i, bank.bank16_NUM);
		mem_i += FILTER#;
		{#}
	);
	bank.bank8_enabled ? (
		{#NUM=0,7}
		single_filter_to_bank(mem_i, bank.bank8_NUM);
		mem_i += FILTER#;
		{#}
	);
	bank.bank4_enabled ? (
		{#NUM=0,3}
		single_filter_to_bank(mem_i, bank.bank4_NUM);
		mem_i += FILTER#;
		{#}
	);
	bank.bank2_enabled ? (
		{#NUM=0,1}
		single_filter_to_bank(mem_i, bank.bank2_NUM);
		mem_i += FILTER#;
		{#}
	);
	bank.bank1_enabled ? (
		single_filter_to_bank(mem_i, bank.bank1_0);
		mem_i += FILTER#;
	);
);

/********* Filter-bank functions *********/

function filter_step() (
	this.a1 += this.a1_step;
	this.a2 += this.a2_step;
	this.b0 += this.b0_step;
	this.b1 += this.b1_step;
	this.b2 += this.b2_step;
);

function step_bank_filters(filter*) local(i, filter_mem_i) (
	{#N=0,15}
	filter.bank16_N.filter_step();
	{#}
	{#N=0,7}
	filter.bank8_N.filter_step();
	{#}
	{#N=0,3}
	filter.bank4_N.filter_step();
	{#}
	{#N=0,1}
	filter.bank2_N.filter_step();
	{#}
	filter.bank1_0.filter_step();
);

function bank_filter(x, filter*) local() (
	filter.bank16_enabled ? (
		{#NUM=0,15}
		x = filter.bank16_NUM.filter_sample(x);
		{#}
	);
	filter.bank8_enabled ? (
		{#NUM=0,7}
		x = filter.bank8_NUM.filter_sample(x);
		{#}
	);
	filter.bank4_enabled ? (
		{#NUM=0,3}
		x = filter.bank4_NUM.filter_sample(x);
		{#}
	);
	filter.bank2_enabled ? (
		{#NUM=0,1}
		x = filter.bank2_NUM.filter_sample(x);
		{#}
	);
	filter.bank1_enabled ? (
		x = filter.bank1_0.filter_sample(x);
	);
	x;
);

/********* Memory-filter functions *********/

function gain_window_tapered(x) (
	0.5 - 0.5*cos(x*2*$pi);
);

function calculate_filters(filter_mem, current_phase) local(i, freq, gain, band_gain, bw, future_samples, future_factor, future_phase, filter_mem_i) (
	// Calculate filter targets
	// Future time is min(samples_to_next_block, [when the next filter will pop off an edge])
	// Predict that far in future, divide by distance
	future_samples = samples_to_next_block;
	cycle_phase_step > 0 ? (
		future_samples = min(future_samples, ceil((1 - current_phase)/cycle_phase_step));
	) : cycle_phase_step < 0 ? (
		future_samples = min(future_samples, ceil(current_phase/-cycle_phase_step));
	);
	future_factor = future_samples ? 1/future_samples : 0;

	future_phase = current_phase + cycle_phase_step*future_samples;

	bw = filter_width_factor*(log(high_freq/low_freq)/log(2)/band_count);

	actual_band_count = band_count + 2;
	i = 0;
	loop(band_count + 2,
		filter_mem_i = filter_mem + 14/*FILTER: A1, A2, B0, B1, B2, A1_STEP, A2_STEP, B0_STEP, B1_STEP, B2_STEP, Y1, X1, Y2, X2*/*i;
		i >= band_count ? (
			band_gain = pow(10, -filter_db/20);
			filter_mode == 1 ? (
				gain = sqrt(band_gain)*(0.1 + filter_width_factor);
				gain = pow(10, -0.6*filter_db*(0.1 + filter_width_factor)/20);
				i == band_count ? (
					freq = 1/(1.18 + band_gain)*low_freq*exp(log(high_freq/low_freq)*(band_count - 0.4)/band_count);
					target_filter.filter_highshelf_gainslope(freq/srate, 1/gain, 1);
				) : (
					freq = (1.18 + band_gain)*low_freq*exp(log(high_freq/low_freq)*(0.4)/band_count);
					target_filter.filter_highshelf_gainslope(freq/srate, gain, 1);
				);
			) : (
				// Magic equations found through trial and error!
				gain = 1 + (1 - band_gain)*1.2*filter_width_factor*filter_width_factor;
				i == band_count ? (
					freq = 1/(1.18 + band_gain)*low_freq*exp(log(high_freq/low_freq)*(band_count - 0.4)/band_count);
					target_filter.filter_highshelf_gainslope(freq/srate, 1/gain, 1.8 - band_gain);
				) : (
					freq = (1.18 + band_gain)*low_freq*exp(log(high_freq/low_freq)*(0.4)/band_count);
					target_filter.filter_highshelf_gainslope(freq/srate, gain, 1.8 - band_gain);
				);
			);
		) : (
			freq = low_freq*exp(log(high_freq/low_freq)*(i + future_phase)/band_count);
			filter_mode == 1 ? (
				gain = pow(10, 0.5*filter_db/20);
				gain = 1 + (gain - 1)*gain_window_tapered((i + future_phase)/band_count);
				target_filter.filter_band(freq, gain, bw);
			) : (
				gain = pow(10, -filter_db*gain_window_tapered((i + future_phase)/band_count)/20);
				target_filter.filter_notch(freq, bw, gain);
			);
		);

		!future_samples ? (
			filter_mem_i[FILTER#A1] = target_filter.a1;
			filter_mem_i[FILTER#A2] = target_filter.a2;
			filter_mem_i[FILTER#B0] = target_filter.b0;
			filter_mem_i[FILTER#B1] = target_filter.b1;
			filter_mem_i[FILTER#B2] = target_filter.b2;
		);
		filter_mem_i[FILTER#A1_STEP] = (target_filter.a1 - filter_mem_i[FILTER#A1])*future_factor;
		filter_mem_i[FILTER#A2_STEP] = (target_filter.a2 - filter_mem_i[FILTER#A2])*future_factor;
		filter_mem_i[FILTER#B0_STEP] = (target_filter.b0 - filter_mem_i[FILTER#B0])*future_factor;
		filter_mem_i[FILTER#B1_STEP] = (target_filter.b1 - filter_mem_i[FILTER#B1])*future_factor;
		filter_mem_i[FILTER#B2_STEP] = (target_filter.b2 - filter_mem_i[FILTER#B2])*future_factor;

		i += 1;
	);

	actual_band_count;
);

function clear_filters(filter_mem) local(i, filter_mem_i) (
	memset(filter_mem, 0, MAX_BAND_COUNT*FILTER#);

	i = 0;
	loop(MAX_BAND_COUNT,
		filter_mem_i = filter_mem + FILTER#*i;
		filter_mem_i[FILTER#B0] = 1;
		i += 1;
	);
);

function shift_filters_down(filter_mem) local(i, filter_mem_i) (
	// Shunt all filters down
	i = band_count*FILTER# - 1;
	while (i >= FILTER#) (
		filter_mem[i] = filter_mem[i - FILTER#];
		i -= 1;
	);

	// New filter coeffs: 0-gain at low_freq
	bw = filter_width_factor*(log(high_freq/low_freq)/log(2)/band_count);
	target_filter.filter_band(low_freq, 1, bw);
	shift_down_new_filter.filter_band(low_freq, 1, bw);
	// Copy coefficients
	filter_mem_i = filter_mem;
	filter_mem_i[FILTER#A1] = target_filter.a1;
	filter_mem_i[FILTER#A2] = target_filter.a2;
	filter_mem_i[FILTER#B0] = target_filter.b0;
	filter_mem_i[FILTER#B1] = target_filter.b1;
	filter_mem_i[FILTER#B2] = target_filter.b2;

	// Rewrite output - zero gain, so should be same as input
	filter_mem_i[FILTER#Y1] = filter_mem_i[FILTER#X1];
	filter_mem_i[FILTER#Y2] = filter_mem_i[FILTER#X2];
);

function shift_filters_up(filter_mem) local(i, bw, filter_mem_i) (
	// Shunt all filters up
	i = 0;
	while (i < (band_count - 1)*FILTER#) (
		filter_mem[i] = filter_mem[i + FILTER#];
		i += 1;
	);

	// New filter coeffs: 0-gain at high_freq
	bw = filter_width_factor*(log(high_freq/low_freq)/log(2)/band_count);
	target_filter.filter_band(high_freq, 1, bw);
	// Copy coefficients
	filter_mem_i = filter_mem + (band_count - 1)*FILTER#;
	filter_mem_i[FILTER#A1] = target_filter.a1;
	filter_mem_i[FILTER#A2] = target_filter.a2;
	filter_mem_i[FILTER#B0] = target_filter.b0;
	filter_mem_i[FILTER#B1] = target_filter.b1;
	filter_mem_i[FILTER#B2] = target_filter.b2;

	// Rewrite output - zero gain, so should be same as input
	filter_mem_i[FILTER#Y1] = filter_mem_i[FILTER#X1];
	filter_mem_i[FILTER#Y2] = filter_mem_i[FILTER#X2];
);

function correction_amp(filter_mem, freq) local(wi, wr, hi, hr, pr, pi, pm2, zr, zi, tr, ti, i, filter_mem_i) (
	hr = 1;
	hi = 0;
	wr = cos(2*$pi*freq/srate);
	wi = sin(2*$pi*freq/srate);
	w2r = cos(4*$pi*freq/srate);
	w2i = sin(4*$pi*freq/srate);

	i = 0;
	while (i < actual_band_count) (
		filter_mem_i = filter_mem + FILTER#*i;
		// Numerator (B)
		zr = filter_mem_i[FILTER#B0] + filter_mem_i[FILTER#B1]*wr + filter_mem_i[FILTER#B2]*w2r;
		zi = filter_mem_i[FILTER#B1]*wi + filter_mem_i[FILTER#B2]*w2i;
		// Denominator (B)
		pr = 1 + filter_mem_i[FILTER#A1]*wr + filter_mem_i[FILTER#A2]*w2r;
		pi = filter_mem_i[FILTER#A1]*wi + filter_mem_i[FILTER#A2]*w2i;
		pm2 = pr*pr + pi*pi;

		// Multiply by numerator
		tr = hr;
		ti = hi;
		hr = tr*zr - ti*zi;
		hi = tr*zi + ti*zr;

		// Divide by denominator
		tr = hr;
		ti = hi;
		hr = tr*pr + ti*pi;
		hi = ti*pr - tr*pi;
		hr /= pm2;
		hi /= pm2;
		i += 1;
	);
	sqrt(hr*hr + hi*hi);
);

/********* Let's go *********/

cycle_phase = play_position*cycle_phase_lfo_hz + beat_position*cycle_phase_invbeat + cycle_phase_offset;
cycle_phase -= floor(cycle_phase);
cycle_phase_offset_prev = cycle_phase_offset;

samples_to_next_block = 0;
cycle_phase_step = 0;

function calculate_filters_stereo() local(new_phase) (
	new_phase = cycle_phase - cycle_phase_stereo_offset*0.5;
	cycle_phase_left = new_phase + floor(cycle_phase_left - new_phase + 0.5);
	calculate_filters(filter_mem_l, cycle_phase_left);

	new_phase = cycle_phase + cycle_phase_stereo_offset*0.5;
	cycle_phase_right = new_phase + floor(cycle_phase_right - new_phase + 0.5);
	calculate_filters(filter_mem_r, cycle_phase_right);
);
filters_to_mem(filter_mem_l, filter_bank_left);
filters_to_mem(filter_mem_r, filter_bank_right);
calculate_filters_stereo();
filters_to_bank(filter_mem_l, filter_bank_left);
filters_to_bank(filter_mem_r, filter_bank_right);

output_gain = pow(10, output_gain_db/20);
output_gain_step = 0;

gain = (control_band_count == band_count && control_filter_mode == filter_mode) ? 1 : 0;
gain_step = 0;
gain_step_max = 1/(0.05*srate);

no_lfo_since_init = 1;

@block

output_gain_step = (pow(10, output_gain_db/20) - output_gain)/samplesblock;

control_band_count == band_count && control_filter_mode == filter_mode ? (
	gain_step = max(-gain_step_max, min(gain_step_max, (1 - gain)/samplesblock));
) : (
	gain < 0.001 ? (
		band_count = control_band_count;
		filter_mode = control_filter_mode;
		gain_step = max(-gain_step_max, min(gain_step_max, (1 - gain)/samplesblock));

		samples_to_next_block = 0;
		cycle_phase_step = 0;

		clear_filters(filter_mem_l);
		clear_filters(filter_mem_r);
		calculate_filters_stereo();
		filters_to_bank(filter_mem_l, filter_bank_left);
		filters_to_bank(filter_mem_r, filter_bank_right);
	) : (
		gain_step = max(-gain_step_max, min(gain_step_max, -gain/samplesblock));
	);
);

secondsblock = samplesblock/srate;

beat_blockdelta = secondsblock*tempo/60;
cycle_phase_blockdelta = beat_blockdelta*cycle_phase_invbeat + secondsblock*cycle_phase_lfo_hz;

cycle_phase_lfo_hz ? no_lfo_since_init = 0;
// Figure out what phase *should* be, and slew over next block
play_state > 0 && play_state != 6 ? (
	!no_lfo_since_init ? (
		// Difference between expectation and actual beat-based phase + offset
		cycle_phase_adjustment = (beat_position - beat_position_next_block)*cycle_phase_invbeat
			+ cycle_phase_offset - cycle_phase_offset_prev;
	) : (
		// No LFO - lock exactly to beat + offset
		cycle_phase_adjustment = beat_position*cycle_phase_invbeat + cycle_phase_offset - cycle_phase;
	);
) : (
	cycle_phase_invbeat || !no_lfo_since_init ? (
		// We're freewheeling anyway, just track offset changes
		cycle_phase_adjustment = cycle_phase_offset - cycle_phase_offset_prev;
	) : (
		// Everything's set to zero - it's just following the offset
		cycle_phase_adjustment = cycle_phase_offset - cycle_phase;
	);
);

cycle_phase_adjustment -= floor(cycle_phase_adjustment + 0.5);
// Make up for the difference during this block
cycle_phase_blockdelta += cycle_phase_adjustment;

samples_to_next_block = samplesblock;
cycle_phase_step = cycle_phase_blockdelta/samplesblock;

filters_to_mem(filter_mem_l, filter_bank_left);
filters_to_mem(filter_mem_r, filter_bank_right);
calculate_filters_stereo();
filters_to_bank(filter_mem_l, filter_bank_left);
filters_to_bank(filter_mem_r, filter_bank_right);

// Phase logging
phase_logger_buffer[phase_logger_index] = cycle_phase;
phase_logger_index += 1;
phase_logger_index >= phase_logger_length ? (
	phase_logger_index = 0;
);

// Get ready for the next block
beat_position_next_block = beat_position + beat_blockdelta;
cycle_phase_offset_prev = cycle_phase_offset;
cycle_phase += cycle_phase_blockdelta;
cycle_phase -= floor(cycle_phase);

@sample

spl0 = bank_filter(spl0*gain, filter_bank_left);
spl1 = bank_filter(spl1*gain, filter_bank_right);

step_bank_filters(filter_bank_left);
step_bank_filters(filter_bank_right);

cycle_phase_left += cycle_phase_step;
while (cycle_phase_left > 1) (
	cycle_phase_left -= 1;
	filters_to_mem(filter_mem_l, filter_bank_left);
	shift_filters_down(filter_mem_l);
	calculate_filters(filter_mem_l, cycle_phase_left);
	filters_to_bank(filter_mem_l, filter_bank_left);
);
while (cycle_phase_left < 0) (
	cycle_phase_left += 1;
	filters_to_mem(filter_mem_l, filter_bank_left);
	shift_filters_up(filter_mem_l);
	calculate_filters(filter_mem_l, cycle_phase_left);
	filters_to_bank(filter_mem_l, filter_bank_left);
);
cycle_phase_right += cycle_phase_step;
while (cycle_phase_right > 1) (
	cycle_phase_right -= 1;
	filters_to_mem(filter_mem_r, filter_bank_right);
	shift_filters_down(filter_mem_r);
	calculate_filters(filter_mem_r, cycle_phase_right);
	filters_to_bank(filter_mem_r, filter_bank_right);
);
while (cycle_phase_right < 0) (
	cycle_phase_right += 1;
	filters_to_mem(filter_mem_r, filter_bank_right);
	shift_filters_up(filter_mem_r);
	calculate_filters(filter_mem_r, cycle_phase_right);
	filters_to_bank(filter_mem_r, filter_bank_right);
);

spl0 *= gain*output_gain;
spl1 *= gain*output_gain;
gain += gain_step;
output_gain += output_gain_step;

samples_to_next_block -= 1;

@gfx 600 440

function labels(label, value, number_format) local(h) (
	h = max((ui_height() - 60)/2, ui_height()*0.2);
	ui_split_top(h);
		ui_align(0.5, 1);
		ui_text(label);
	ui_pop();
	ui_split_bottom(h);
		ui_align(0.5, 0);
		number_format >= 0 ? (
			ui_textnumber(value, number_format);
		);
	ui_pop();
);
function labels(label) local(h) (
	labels(label, 0, "");
);

control_start("main", "tron");

ui_screen() == "main" ? (
	ui_split_bottom(250);
		ui_split_topratio(0.5);
			ui_split_leftratio(3/6);
				control_group("Filters");
				ui_split_leftratio(1/3);
					labels("Type", 0, filter_mode == 1 ? "peak" : "notch");
					control_filter_mode = control_switch(control_filter_mode);
				ui_split_next();
					labels("Strength");
					ui_automate(filter_db, control_dial(filter_db, 0, 60, 1, 40));
				ui_split_next();
					labels("Focus");
					ui_automate(filter_width_factor, control_dial(filter_width_factor, 0.7, 0.01, -2, 0.5));
				ui_pop();
			ui_pop();

			control_group("LFO");
			ui_split_leftratio(1/3);
				labels("Freq", cycle_phase_lfo_hz, cycle_phase_lfo_hz >= 1 ? "%.1f Hz" : "%.2f Hz");
				ui_automate(cycle_phase_lfo_hz, control_dial(cycle_phase_lfo_hz, -10, 10, 0, 0));
			ui_split_next();
				labels("Tempo", cycle_phase_invbeat, "%.1f / beat");
				cycle_phase_invbeat != floor(cycle_phase_invbeat_float*2 + 0.5)*0.5 ? (
					cycle_phase_invbeat_float = cycle_phase_invbeat;
				);
				cycle_phase_invbeat_float = control_dial(cycle_phase_invbeat_float, -4, 4, 0, 0);
				ui_automate(cycle_phase_invbeat, floor(cycle_phase_invbeat_float*2 + 0.5)*0.5);
			ui_split_next();
				control_background_technical();
				ui_graph(phase_logger_buffer, phase_logger_length, phase_logger_index, 0, 1);
				control_finish_technical();
			ui_pop();
		ui_split_next();
			ui_split_leftratio(3/6);
				control_group("Bands");
				ui_split_leftratio(1/3);
					labels("Count", control_band_count, "%i filters");
					control_band_count != floor(control_band_count_float + 0.5) ? (
						control_band_count_float = control_band_count;
					);
					control_band_count_float = control_dial(control_band_count_float, 1.6, 20.4, 2, 6);
					ui_automate(control_band_count, floor(control_band_count_float + 0.5));
				ui_split_next();
					labels("Low", low_freq, "%i Hz");
					ui_automate(low_freq, min(high_freq*0.5, control_dial(low_freq, 20, 2000, 5, 100)));
				ui_split_next();
					labels("High", high_freq, "%i Hz");
					ui_automate(high_freq, max(low_freq*2, control_dial(high_freq, 1000, 20480, 5, 12000)));
				ui_pop();
			ui_pop();

			ui_split_leftratio(2/3);
				control_group("Phase");
				ui_split_leftratio(1/2);
					labels("Offset");
					ui_automate(cycle_phase_offset, control_dial_angle_unit(cycle_phase_offset, 0));
				ui_split_next();
					labels("Stereo");
					ui_automate(cycle_phase_stereo_offset, control_dial(cycle_phase_stereo_offset, -0.5, 0.5, 0, 0));
				ui_pop();
			ui_pop();

			ui_split_leftratio(1/1);
				control_group("Output");
				labels("Gain", output_gain_db, "%.1fdB");
				ui_automate(output_gain_db, control_dial(output_gain_db, -12, 6, -1.4, 0));
			ui_pop();
		ui_pop();
	ui_pop();

	control_background_technical();

	plot.frequency_graph_init(20, 18000, -20, 20);
	plot.frequency_graph_grid();

	ui_color(256, 192, 64, 0.8);
	g_i = 0;
	loop(g_buffer_length,
		g_freq = 20*exp(log(18000/20)*g_i/g_buffer_length);
		g_buffer[g_i] = log(correction_amp(filter_mem_l, g_freq))*20/log(10) + output_gain_db;
		g_i += 1;
	);
	ui_graph(g_buffer, g_buffer_length, -20, 20);

	ui_color(96, 192, 256, 1);
	g_i = 0;
	loop(g_buffer_length,
		g_freq = 20*exp(log(18000/20)*g_i/g_buffer_length);
		g_buffer[g_i] = log(correction_amp(filter_mem_r, g_freq))*20/log(10) + output_gain_db;
		g_i += 1;
	);
	ui_graph(g_buffer, g_buffer_length, -20, 20);

	control_finish_technical();
) : control_system();

@serialize

preset_version = 1;
file_var(0, preset_version);