Stereo Alignment Delay.jsfx

desc:Stereo Alignment Delay (by Geraint Luff)

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

slider1:delay_ms_l=0<-125,125,0.1>-Left delay (ms)
slider2:delay_ms_r=0<-125,125,0.1>-Right delay (ms)
slider3:delay_linked=0<0,1,1{no,yes}>-Linked
slider4:display_units_in_samples=0<0,1,1{ms,samples}>-Units
slider5:delay_fftsize_1024log2=3<0,4,1{1024,2048,4096,8192,16384}>-Analysis FFT Size
slider6:phase_invert_l=0<0,1,1{normal,invert}>-Left phase
slider7:phase_invert_r=0<0,1,1{normal,invert}>-Right phase
slider8:amplitude_mode=0<0,3,1{symmetric,reference left,reference right,sharp}>-Input reference

options:gmem=geraintluffStereoAlignmentDelayComms

import ui-lib.jsfx-inc

@init

SILENCE_DB = -120;
SILENCE_POWER = pow(10, SILENCE_DB/10);

gfx_ext_retina = 1;

send_routing_id == 0 ? send_routing_id = rand()*1048576 + 1;
send_routing_length = 1*srate; // Maximum supported latency difference
//send_routing_index = 0;
_GMEM_SOURCE_ID = 0;
_GMEM_SOURCE_LENGTH = 1;
_GMEM_SOURCE_INDEX = 2;
_GMEM_SOURCE_PLAY_POSITION = 3;
_GMEM_SOURCE_LAST_ACTIVE_TIME = 4;
_GMEM_SOURCE_CORRECT_SENDING = 5;
_GMEM_ADJUST_ACTION = 8;
_GMEM_ADJUST_MS = 9;
_GMEM_ADJUST_PHASE = 10;
_GMEM_BUFFER_OFFSET = 16;

MAX_DELAY = 0.125;
MAX_PREDELAY = 0.125;

freemem = ui_setup(0);
buffer_length = ceil(srate*(MAX_PREDELAY + MAX_PREDELAY) + 100);
freemem = (buffer0 = freemem) + buffer_length;
freemem = (buffer1 = freemem) + buffer_length;
buffer_index = 0;

gain = 0;
gain_step = 0;

MAX_FFTSIZE = 32768;
delay_bufferlength = max(MAX_FFTSIZE, send_routing_length + buffer_length);
freemem = (delay_bufferA = freemem) + delay_bufferlength;
freemem = (delay_bufferB = freemem) + delay_bufferlength;
freemem = 65536*ceil(freemem/65536);
freemem = (fft_bufferA = freemem) + MAX_FFTSIZE*2;
freemem = (fft_bufferB = freemem) + MAX_FFTSIZE*2;
freemem = (delay_bufferSum = freemem) + MAX_FFTSIZE;

i = 0;
while (i < MAX_FFTSIZE) (
	delay_bufferA[i] = delay_bufferB[i] = 0;
	i += 1;
);

force_reset = 1;

@block

new_delay_samples_l = floor(delay_ms_l*srate*0.001 + 0.5);
new_delay_samples_r = floor(delay_ms_r*srate*0.001 + 0.5);
new_predelay_samples = -min(0, min(new_delay_samples_l, new_delay_samples_r));
new_delay_samples_l += new_predelay_samples;
new_delay_samples_r += new_predelay_samples;

new_polarity_l = phase_invert_l ? -1 : 1;
new_polarity_r = phase_invert_r ? -1 : 1;

force_reset
|| delay_samples_l != new_delay_samples_l
|| delay_samples_r != new_delay_samples_r
|| new_polarity_l != polarity_l
|| new_polarity_r != polarity_r
|| new_predelay_samples != predelay_samples ? (
	gain <= 0 ? (
		force_reset = 0;
		// We've already faded out - update
		delay_samples_l = new_delay_samples_l;
		delay_samples_r = new_delay_samples_r;
		pdc_delay = predelay_samples = new_predelay_samples;
		pdc_bot_ch = 0;
		pdc_top_ch = 2;

		polarity_l = new_polarity_l;
		polarity_r = new_polarity_r;

		gain_step = 1/samplesblock;
	) : (
		gain_step = -1/samplesblock;
	);
	gain += gain_step;
) : (
	gain_step = (1 - gain)/samplesblock;
);

gmem[0] === send_routing_id ? (
	gmem[_GMEM_SOURCE_LENGTH] = send_routing_length;
	gmem[_GMEM_SOURCE_INDEX] = send_routing_index;
	gmem[_GMEM_SOURCE_PLAY_POSITION] = play_position - predelay_samples/srate;
	gmem[_GMEM_SOURCE_LAST_ACTIVE_TIME] = time();

	gmem[_GMEM_ADJUST_ACTION] ? (
		gmem[_GMEM_ADJUST_ACTION] = 0;
		adjust_ms = gmem[_GMEM_ADJUST_MS];
		gmem[_GMEM_ADJUST_PHASE] ? (
			phase_invert_l = !phase_invert_l;
			phase_invert_r = !phase_invert_r;
		);
		delay_ms_l += adjust_ms;
		delay_ms_r += adjust_ms;

		// Stop sending
		gmem[0] = 0;
	);
);

delay_analysis_active ? (
	block_play_position = play_position - predelay_samples/srate;
	block_delay_bufferindex = delay_bufferindex;
);

currently_sending = (gmem[0] === send_routing_id);

@sample

function perform_delay_analysis() local(i, delay_index, ratio, window, rA, iA, rB, iB, mag2, factor, max_abs, max_index, max_phase, energySum) (
	action_delay_analysis_reset ? (
		delay_peak_minsample = delay_peak_maxsample = 0;
	);

	delay_fftsize = 1024<<delay_fftsize_1024log2;
	receive_routing_id = (abs(time() - gmem[_GMEM_SOURCE_LAST_ACTIVE_TIME]) < 5) ? gmem[0] : 0;

	// Reset the analysis if anything has changed
	gmem[_GMEM_SOURCE_CORRECT_SENDING] != old_correct_sending || prev_receive_routing_id !== receive_routing_id || amplitude_mode !== prev_amplitude_mode || delay_fftsize != old_delay_fftsize || action_delay_analysis_reset ? (
		old_correct_sending = gmem[_GMEM_SOURCE_CORRECT_SENDING];
		prev_receive_routing_id = receive_routing_id;
		prev_amplitude_mode = amplitude_mode;
		old_delay_fftsize = delay_fftsize;
		i = 0;
		while (i < delay_fftsize) (
			delay_bufferSum[i] = 0;
			i += 1;
		);
		i = 0;
		while (i < delay_bufferlength) (
			delay_bufferA[i] = delay_bufferB[i] = 0;
			i += 1;
		);
		delay_bufferindex = 0;

		delay_fftinterval = delay_fftsize/4;
		delay_fftinterval_counter = -delay_fftsize + delay_fftinterval; // First analysis when we've captured a full FFT length

		action_delay_analysis_reset = 0;
	);

	delay_bufferA[delay_bufferindex] = spl0;
	delay_bufferB[delay_bufferindex] = spl1;
	delay_bufferindex += 1;
	delay_bufferindex >= delay_bufferlength ? (
		delay_bufferindex = 0;
	);

	delay_fftinterval_counter += 1;
	delay_fftinterval_counter >= delay_fftinterval ? (
		delay_fftinterval_counter = 0;

		receive_routing_id ? (
			// Use local/remote inputs
			receive_index = gmem[_GMEM_SOURCE_INDEX];
			receive_length = gmem[_GMEM_SOURCE_LENGTH];
			// Try to detect latency difference (might be calculating different points)
			receive_sample_difference = srate*(block_play_position - gmem[_GMEM_SOURCE_PLAY_POSITION]);
			receive_sample = floor(receive_sample_difference + 0.5);
			// How to compensate
			extra_local_delay = max(receive_sample_difference, 0);
			extra_remote_delay = max(-receive_sample_difference, 0);

			i = 0;
			while (i < delay_fftsize) (
				ratio = ((i + 0.5)/delay_fftsize);
				window = 0.5 - 0.5*cos(ratio*2*$pi);

				delay_index_l = block_delay_bufferindex - extra_local_delay - delay_samples_l - delay_fftsize + i + 1;
				delay_index_l < 0 ? delay_index_l += delay_bufferlength;
				delay_index_r = block_delay_bufferindex - extra_local_delay - delay_samples_r - delay_fftsize + i + 1;
				delay_index_r < 0 ? delay_index_r += delay_bufferlength;
				fft_bufferA[i*2] = (delay_bufferA[delay_index_l]*polarity_l + delay_bufferB[delay_index_r]*polarity_r)*window;
				fft_bufferA[i*2 + 1] = 0;

				remote_index = receive_index - extra_remote_delay - delay_fftsize + i + 1;
				remote_index < 0 ? remote_index += receive_length;
				fft_bufferB[i*2] = gmem[_GMEM_BUFFER_OFFSET + remote_index]*window;
				fft_bufferB[i*2 + 1] = 0;
				i += 1;
			);
		) : (
			// Use left/right inputs
			i = 0;
			while (i < delay_fftsize) (
				ratio = ((i + 0.5)/delay_fftsize);
				window = 0.5 - 0.5*cos(ratio*2*$pi);

				delay_index = delay_bufferindex - delay_fftsize + i + 1;
				delay_index < 0 ? delay_index += delay_bufferlength;
				fft_bufferA[i*2] = delay_bufferA[delay_index]*window;
				fft_bufferA[i*2 + 1] = 0;
				fft_bufferB[i*2] = delay_bufferB[delay_index]*window;
				fft_bufferB[i*2 + 1] = 0;
				i += 1;
			);
		);

		fft(fft_bufferA, delay_fftsize);
		fft(fft_bufferB, delay_fftsize);
		i = 0;
		while (i < delay_fftsize) (
			rA = fft_bufferA[2*i];
			iA = fft_bufferA[2*i + 1];
			rB = fft_bufferB[2*i];
			iB = fft_bufferB[2*i + 1];
			// Magnitude by which we divide - A, B or both
			// The one being corrected determines the amplitude, so doesn't get divided
			amplitude_mode === 1 || (receive_routing_id && gmem[_GMEM_SOURCE_CORRECT_SENDING]) ? (
				mag2 = (rA*rA + iA*iA);
			) : amplitude_mode === 2 || (receive_routing_id && !gmem[_GMEM_SOURCE_CORRECT_SENDING]) ? (
				mag2 = (rB*rB + iB*iB);
			) : (
				mag2 = (rA*rA + iA*iA)*(rB*rB + iB*iB);
				amplitude_mode === 0 ? (
					mag2 = sqrt(mag2);
				);
			);
			mag = sqrt(mag2);
			factor = 1/(max(mag, 0.000001))/delay_fftsize;
			fft_bufferA[2*i] = (rA*rB + iA*iB)*factor;
			fft_bufferA[2*i + 1] = (-rA*iB + iA*rB)*factor;
			i += 1;
		);
		ifft(fft_bufferA, delay_fftsize);

		max_abs = 0;
		max_phase = 1;
		max_index = 0;

		analysis_decay_invsamples = analysis_decay_hz/srate;
		analysis_decay_samples = srate / analysis_decay_hz;
		analysis_decay_factor = analysis_decay_hz === 0 ? 1 : exp(-delay_fftinterval/analysis_decay_samples);

		energySum = 0;
		i = 0;
		while (i < delay_fftsize) (
			i2 = (i + delay_fftsize/2)%delay_fftsize;
			value = delay_bufferSum[i2] = delay_bufferSum[i2]*analysis_decay_factor + fft_bufferA[2*i];
			abs(value) >= max_abs ? (
				i_wrapped = (i > delay_fftsize/2) ? i - delay_fftsize : i;

				(delay_peak_minsample == delay_peak_maxsample) || (
					i_wrapped >= min(delay_peak_minsample, delay_peak_maxsample)
					&& i_wrapped <= max(delay_peak_minsample, delay_peak_maxsample)
				) ? (
					max_abs = abs(delay_bufferSum[i2]);
					max_index = i_wrapped;
					max_phase = delay_bufferSum[i2] < 0 ? -1 : 1;
				);
			);
			energySum += value*value;
			i += 1;
		);
		delay_bufferSum_energy = energySum/delay_fftsize;

		delay_samples = max_index;
		delay_phase = max_phase;
	);
);

delay_analysis_active ? (
	perform_delay_analysis();
);

buffer0[buffer_index] = spl0;
buffer1[buffer_index] = spl1;
delayed_l = buffer_index - delay_samples_l;
delayed_l < 0 ? delayed_l += buffer_length;
delayed_r = buffer_index - delay_samples_r;
delayed_r < 0 ? delayed_r += buffer_length;

spl0 = buffer0[delayed_l]*gain*polarity_l;
spl1 = buffer1[delayed_r]*gain*polarity_r;
gain += gain_step;

buffer_index += 1;
buffer_index >= buffer_length ? buffer_index = 0;

currently_sending ? (
	// We're sending - write to the shared buffer
	// We use the mono signal, assuming that we're aligned already
	gmem[_GMEM_BUFFER_OFFSET + send_routing_index] = spl0 + spl1;

	send_routing_index += 1;
	send_routing_index > send_routing_length ? (
		send_routing_index = 0;
	);
);

@gfx 490 330

DIAL_HEIGHT = 50;

function doublebiasdial(value, low, centre, high, bias) local(ratio, newratio) (
	value < centre ? (
		ratio = -uix_slider_value_to_ratio(value, centre, low, bias);
	) : (
		ratio = uix_slider_value_to_ratio(value, centre, high, bias);
	);
	newratio = control_dial(ratio, -1, 1, 0);
	newratio != ratio ? (
		newratio < 0 ? (
			value = uix_slider_ratio_to_value(-newratio, centre, low, bias);
		) : (
			value = uix_slider_ratio_to_value(newratio, centre, high, bias);
		);
	);
	value;
);

delay_analysis_active = (ui_screen() == "delay-analysis");

function titleabove(text) (
	ui_push_above(DIAL_HEIGHT);
		ui_align(0.5, 0.9);
		ui_text(text);
	ui_pop();
);

function readoutbelow(number, pattern) (
	ui_push_below(DIAL_HEIGHT);
		ui_align(0.5, 0.1);
		ui_textnumber(number, pattern);
	ui_pop();
);

function readout_entry_below(actual, number, pattern) (
	ui_push_below(DIAL_HEIGHT);
		ui_align(0.5, 0.1);
		number = control_hidden_textnumber(actual, number, pattern);
	ui_pop();
	number;
);

function delaydial(delayms, title) local(samples) (
	titleabove(title);

	ui_push_height(DIAL_HEIGHT);
		delayms = doublebiasdial(delayms, -MAX_PREDELAY*1000, 0, MAX_DELAY*1000, 6);
	ui_pop();

	display_units_in_samples ? (
		samples = floor(delayms*srate*0.001 + 0.5);
		newsamples = readout_entry_below(samples, samples, "%i");
		newsamples !== samples ? (
			delayms = newsamples*1000/srate;
		);
	) : (
		delayms = readout_entry_below(delayms, floor(delayms*100 + 0.5)*0.01 + (delayms >= 0 ? 0.004 : -0.004), "%.2fms");
	);
	delayms = max(-MAX_PREDELAY*1000, min(MAX_DELAY*1000, delayms));

	ui_click() && ui_clickcount() == 2 ? (
		delayms = 0;
	);

	delayms;
);

function labelledswitch(value, title, ontext, offtext) (
	titleabove(title);
	ui_push_height(DIAL_HEIGHT*0.7);
		ui_push_width(DIAL_HEIGHT*1.25);
			value = control_switch(value);
		ui_pop();
	ui_pop();
	readoutbelow(0, value ? ontext : offtext);
	value;
);

control_start("main", "tron");

gmem[0] === send_routing_id ? (
	ui_pad();
	ui_split_toptext(-1);
		ui_split_left(50);
			ui_pad(0, 5);
			gmem[_GMEM_SOURCE_CORRECT_SENDING] = control_switch(gmem[_GMEM_SOURCE_CORRECT_SENDING]);
		ui_pop();
		ui_padleft();
		ui_align(0, 0.5);
		ui_text(gmem[_GMEM_SOURCE_CORRECT_SENDING] ? "match this instance (receiving is reference)" : "match receiving instance (this is reference)");
	ui_pop();

	ui_split_bottomtext(-1);
		control_button("Done") ? (
			gmem[0] = 0; // Stop routing
		);
	ui_pop();

	ui_push();
		control_background_technical();
		ui_split_topratio(0.5);
			gfx_a = 0.5;
			ui_graph(buffer0, buffer_length, buffer_index>>4, 1, -1);
		ui_split_next();
			gfx_a = 0.5;
			ui_graph(buffer1, buffer_length, buffer_index>>4, 1, -1);
		ui_pop();
		control_finish_technical();
	ui_pop();

	ui_color(255, 255, 255, 0.2);
	ui_texth(min(ui_height()/5, ui_width()/15));
	ui_fontsize(min(ui_height()/5, ui_width()/15));
	ui_text("sending...");
) : ui_screen() == "main" ? (
	control_navbar("Stereo Alignment Delay", -1, -1);

	ui_split_leftratio(1/3);
		control_group("Left");
		ui_split_topratio(1/2);
			delay_ms_l = delaydial(delay_ms_l, "Delay");
			delay_linked ? delay_ms_r = delay_ms_l;
		ui_split_next();
			phase_invert_l = labelledswitch(phase_invert_l, "Phase", "invert", "normal");
			delay_linked ? phase_invert_r = phase_invert_l;
		ui_pop();
	ui_split_next();
		control_group("Right");
		ui_split_topratio(1/2);
			delay_ms_r = delaydial(delay_ms_r, "Delay");
			delay_linked ? delay_ms_l = delay_ms_r;
		ui_split_next();
			phase_invert_r = labelledswitch(phase_invert_r, "Phase", "invert", "normal");
			delay_linked ? phase_invert_l = phase_invert_r;
		ui_pop();
	ui_split_next();
		ui_pad();
		ui_split_bottomtext(-1);
			notesTextState = control_hidden_text(#notesText);
		ui_pop();
		ui_split_bottomtext(-1);
			control_button("send") ? (
				gmem[0] = send_routing_id;
			);
		ui_pop();
		ui_split_bottomtext(-1);
			control_button("detect") ? (
				ui_screen_open("delay-analysis");
				action_delay_analysis_reset = 1;
			);
		ui_pop();

		ui_split_topratio(1/2);
			delay_linked = labelledswitch(delay_linked, "L/R link", "on", "off");
		ui_split_next();
			display_units_in_samples = labelledswitch(display_units_in_samples, "Units", "samples", "ms");
		ui_pop();
	ui_pop();

	ui_padbottom();

	ui_push_height(160);
		control_group("");

		ui_split_leftratio(1/4);
		ui_split_next();
		ui_pop();
	ui_pop();
) : ui_screen() == "delay-analysis" ? (
	g_enough_energy = (delay_bufferSum_energy > SILENCE_POWER);
	control_dialog("Delay analysis", gfx_w*0.9, gfx_h*0.8, receive_routing_id && gmem[_GMEM_SOURCE_CORRECT_SENDING] ? "correct remote" : "correct", "cancel") == 1 ? (
		receive_routing_id ? (
			g_adjust_ms = delay_samples*1000/srate;
			g_adjust_phase = delay_phase < 0;
			gmem[_GMEM_SOURCE_CORRECT_SENDING] ? (
				// Send correction to remote
				gmem[_GMEM_ADJUST_MS] = g_adjust_ms;
				gmem[_GMEM_ADJUST_PHASE] = g_adjust_phase;
				gmem[_GMEM_ADJUST_ACTION] = 1;
			) : (
				delay_ms_l -= g_adjust_ms;
				delay_ms_r -= g_adjust_ms;
				g_adjust_phase ? (
					phase_invert_l = !phase_invert_l;
					phase_invert_r = !phase_invert_r;
				);
				sliderchange(-1);
			);
		) : (
			amplitude_mode == 1  || (amplitude_mode !== 2 && delay_samples >= 0) ? (
				delay_ms_l = 0;
				delay_ms_r = delay_samples*1000/srate;
				phase_invert_l = 0;
				phase_invert_r = delay_phase < 0;
			) : (
				delay_ms_l = -delay_samples*1000/srate;
				delay_ms_r = 0;
				phase_invert_l = delay_phase < 0;
				phase_invert_r = 0;
			);
			delay_linked = 0;
			sliderchange(-1);
		);
	);

	ui_split_bottom(30);
		ui_fontsize(14);
		ui_split_leftratio(0.3);
			receive_routing_id ? (
				control_button("cancel receive") ? (
					gmem[0] = 0;
				);
			) : (
				ui_align(0, 0.5);
				amplitude_mode_text = amplitude_mode == 1 ? (
					"right -> left"
				) : amplitude_mode == 2 ? (
					"left -> right"
				) : amplitude_mode == 3 ? (
					"sym. sharp"
				) : "symmetrical";
				amplitude_mode = control_selector(amplitude_mode, amplitude_mode_text, (amplitude_mode + 1)%4, (amplitude_mode + 3)%4);
			);
		ui_pop();

		ui_split_rightratio(0.3);
			ui_split_right(30);
				analysis_decay_hz = control_dial(analysis_decay_hz, 5, 0, -3);
			ui_pop();
			ui_padright(4);
			ui_align(1, 0.5);
			ui_text("period");
		ui_pop();

		ui_split_righttext("16384 (XYZms)");
			ms_res = floor((1024<<delay_fftsize_1024log2)*0.15/srate*1000);
			sprintf(#fftSizeText, "%i (%ims)", 1024<<delay_fftsize_1024log2, ms_res);
			delay_fftsize_1024log2 = control_selector(delay_fftsize_1024log2, #fftSizeText, min(4, delay_fftsize_1024log2 + 1), max(0, delay_fftsize_1024log2 - 1));
		ui_pop();

		ui_align(1, 0.5);
		ui_padright();
		ui_text("FFT size");
	ui_pop();

	display_size = delay_fftsize*0.3;
	control_background_technical();
	g_enough_energy ? (
		ui_push();
			ui_retina(1);
			ui_color(255, 255, 255, 0.15);
			delay_peak_minsample != delay_peak_maxsample ? (
				peak_x1 = ui_left() + (0.5 + delay_peak_minsample/display_size)*ui_width() + 0.5;
				peak_x2 = ui_left() + (0.5 + delay_peak_maxsample/display_size)*ui_width() + 0.5;
				gfx_rect(min(peak_x1, peak_x2), ui_top(), abs(peak_x2 - peak_x1) + 1, ui_height());
			);

			ui_color(255, 255, 255, 0.5);
			peak_x = ui_left() + (0.5 + delay_samples/display_size)*ui_width() + 0.5;
			gfx_line(peak_x, ui_top(), peak_x, ui_bottom() - 1);
		ui_pop();

		ui_graph_step(delay_bufferSum + floor((delay_fftsize - display_size)*0.5), display_size, 1, 0, 0);
	       ui_hover() ? (
			mouse_sample = ceil((ui_mouse_xratio() - 0.5)*display_size);

			ui_color(255, 128, 128, 0.8);
			ui_retina(1);
			ui_align(1, 1);
			ui_textnumber(mouse_sample, "%i samples");
			ui_align(0, 1);
			ui_textnumber(mouse_sample/srate*1000, "%fms");

			ui_mouse_down() ? (
				delay_peak_minsample = mouse_sample;
				delay_peak_maxsample = mouse_sample;
			);
			ui_press() ? (
				delay_peak_maxsample = mouse_sample;
			);

			ui_color(255, 128, 128, 0.5);
			gfx_line(mouse_x, ui_top(), mouse_x, ui_bottom());
	       );

		ui_push();
			ui_color(255, 255, 255);
			ui_align(delay_samples >= delay_fftsize*0.1 ? 0 : 1, 0);
			ui_split_top(ui_texth());
				g_ms = delay_samples/srate*1000;
				g_ms >= 0 ? (
					amplitude_mode === 2 ? (
						receive_routing_id ? (
							ui_textnumber(g_ms, "Local is %fms behind");
						) : (
							ui_textnumber(g_ms, "Ch0 is %fms behind");
						);
					) : (
						receive_routing_id ? (
							ui_textnumber(g_ms, "Remote is %fms ahead");
						) : (
							ui_textnumber(g_ms, "Ch1 is %fms ahead");
						);
					);
				) : (
					amplitude_mode === 1 ? (
						receive_routing_id ? (
							ui_textnumber(-g_ms, "Remote is %fms behind");
						) : (
							ui_textnumber(-g_ms, "Ch1 is %fms behind");
						);
					) : (
						receive_routing_id ? (
							ui_textnumber(-g_ms, "Local is %fms ahead");
						) : (
							ui_textnumber(-g_ms, "Ch0 is %fms ahead");
						);
					);
				);
			ui_pop();
			ui_split_top(ui_texth());
				ui_textnumber(delay_samples, "(peak at %i samples)");
			ui_pop();
			ui_split_top(ui_texth());
				ui_text(delay_phase > 0 ? "Phase: aligned" : "Phase: inverted");
			ui_pop();
		ui_pop();
	) : (
		ui_text("not enough input");
	);

	receive_routing_id ? (
		ui_align(0.5, 0.9);
		ui_color(255, 255, 255, 0.2);
		ui_texth(min(ui_height()/5, ui_width()/15));
		ui_fontsize(min(ui_height()/5, ui_width()/15));
		ui_text("receiving...");
	);

       control_finish_technical();
) : control_system();

@serialize

preset_version = 1;
file_var(0, preset_version);

preset_version <= 0 ? (
	file_avail(0) >= 0 ? (
		analysis_decay_hz = 0;
	);
);

file_var(0, analysis_decay_hz);

function read_string(string) local(vars_read, char_count, char, string_length) (
	strcpy(string, "");
	string_length = 0;
	file_var(0, char_count);
	vars_read = 1 + char_count;
	string_length < char_count ? while (
		file_var(0, char);
		str_setchar(string, string_length, char);
		string_length += 1;
		string_length < char_count;
	);
	vars_read;
);
function write_string(string) local(string_length, i, char) (
	string_length = strlen(string);
	file_var(0, string_length);
	i = 0;
	i < string_length ? while(
		char = str_getchar(string, i);
		file_var(0, char);
		i += 1;
		i < string_length;
	);
);

preset_version >= 1 ? (
	file_avail(0) >= 0 ? (
		read_string(#notesText);
	) : (
		write_string(#notesText);
	);
);