delay-utils.txt

@init

function sinc(x) (
	abs(x) < 0.000001 ? 1 : sin(x)/x;
);

function delay_config(key, value) (
	key == "interpolation samples" ? (
		this.config.interpolation_samples = min(32, max(4, ceil(value)));
	);
);

function delay_setup(freemem, max_delay_samples) local(i, t, wr, w) (
	this.interp_samples = this.config.interpolation_samples ? this.config.interpolation_samples : 4;
	this.buffer_length = ceil(max_delay_samples + this.interp_samples + 1);
	freemem = (this.buffer = freemem) + this.buffer_length;
	i = 0;
	while (i < this.buffer_length) (
		this.buffer[i] = 0;
		i += 1;
	);
	this.allpass.x1 = this.allpass.x2 = this.allpass.y1 = this.allpass.y2 = 0;

	this.interp_scale = 64;
	this.interp_offset = this.interp_samples/2;
	freemem = (this.interp_buffer = freemem) + this.interp_samples*this.interp_scale;
	i = 0;
	while (i < this.interp_samples*this.interp_scale) (
		wr = (i + 0.5)/(this.interp_samples*this.interp_scale);
		// Blackman window
		w = 0.42 - 0.5*cos(wr*$pi*2) + 0.08*cos(wr*$pi*4);
		t = i/this.interp_scale - this.interp_offset;
		this.interp_buffer[i] = sinc(t*$pi)*w; // Windowed sinc
		i += 1;
	);
	freemem;
);

function delay_init(freemem, max_delay_samples) (
	this.delay_setup(freemem, max_delay_samples);
);

function delay_size(max_delay_samples) local(length, interp_samples, interp_scale) (
	interp_samples = this.config.interpolation_samples ? this.config.interpolation_samples : 4;
	length = ceil(max_delay_samples + interp_samples + 1);
	interp_scale = 64;
	length + interp_scale*interp_samples;
);

function delay_input(spl) (
	this.index += 1;
	this.index >= this.buffer_length ? (
		this.index = 0;
	);
	this.buffer[this.index] = spl;
);

function delay_output_linear1(samples) local(index, index1, value, value2) (
	index = this.index - max(0, samples);
	index1 = floor(index);
	ratio = index - index1;
	while (index1 < 0) (
		index1 += this.buffer_length;
	);
	value = this.buffer[index1];
	index1 += 1;
	value2 = (index1 >= this.buffer_length) ? (
		this.buffer[0];
	) : (
		this.buffer[index1];
	);
	value + ratio*(value2 - value);
);

function delay_output_linear(samples) local(index, index1, index2, ratio, i, interp_index, sum) (
	index = this.index - max(this.interp_samples, samples + this.interp_offset - 1);
	index1 = floor(index);
	ratio = index - index1;
	while (index1 < 0) (
		index1 += this.buffer_length;
	);

	sum = 0;
	index = index1;
	interp_index = floor((1 - ratio)*this.interp_scale);
	i = 0;
	while (i < this.interp_samples) (
		sum += this.interp_buffer[interp_index]*this.buffer[index];
		interp_index += this.interp_scale;
		index += 1;
		index >= this.buffer_length ? (
			index = 0;
		);
		i += 1;
	);
	sum;
);

function delay_output_samples(samples) local(index, buffer) (
	index = this.index - samples;
	while (index < 0) (
		index += this.buffer_length;
	);
	this.buffer[index];
);

function delay_output_allpass(samples)
		local(buffer, interp_buffer, index, index1, index2, Delta, ratio, x0, y0, a1, a2, b0, b1, b2) (
	buffer = this.buffer;
	index = this.index - max(3, samples);
	index1 = ceil(index + 2 + 0.1); // This makes sure Delta is above 2
	Delta = index1 - index;
	Delta = 3;
	while (index1 < 0) (
		index1 += this.buffer_length;
	);

	this.allpass.prev_delay != index1 ? (
		// Reset the filter
		index2 = index1 - 1;
		index2 < 0 ? index2 += this.buffer_length;
		this.allpass.x1 = buffer[index2];
		ratio = max(0, min(1, Delta));
		// Linear interpolation to simulate previous output
		this.allpass.y1 = buffer[index1] + ratio*(buffer[index2] - buffer[index1]);
		this.allpass.prev_delay = index1;
	);

	// Second-order Thiran
	a1 = -2*(Delta - 2)/(Delta + 1);
	a2 = (Delta - 2)*(Delta - 1)/(Delta + 1)/(Delta + 2);
	b0 = a2;
	b1 = a1;
	b2 = 1;

	x0 = buffer[index1];
	y0 = b0*x0 + b1*this.allpass.x1 + b2*this.allpass.x2
		- a1*this.allpass.y1 - a2*this.allpass.y2;
	this.allpass.x2 = this.allpass.x1;
	this.allpass.x1 = x0;
	this.allpass.y2 = this.allpass.y1;
	this.allpass.y1 = y0;
);

/**************** Buffer versions ****************/

function delay_buffer_size(max_delay_samples) local(length, interp_samples, interp_scale) (
	interp_samples = this.config.interpolation_samples ? this.config.interpolation_samples : 4;
	length = ceil(max_delay_samples + interp_samples + 1);
	interp_scale = 64;
	DELAY# + length + interp_scale*interp_samples;
);

function delay_buffer_setup(obj, max_delay_samples) local(i, t, wr, w, obj, buffer, interp_buffer, freemem) (
	i = 0;
	while (i < DELAY#) (
		obj[i] = 0;
		i += 1;
	);

	obj[DELAY#interp_samples] = this.config.interpolation_samples ? this.config.interpolation_samples : 4;
	obj[DELAY#length] = ceil(max_delay_samples + obj[DELAY#interp_samples] + 1);
	obj[DELAY#index] = 0;

	obj[DELAY#allpass_prev_delay] = 1;

	freemem = obj + DELAY#;
	buffer = obj[DELAY#buffer] = freemem;
	freemem = obj[DELAY#buffer] + obj[DELAY#length];
	i = 0;
	while (i < obj[DELAY#length]) (
		buffer[i] = 0;
		i += 1;
	);
	obj[DELAY#interp_scale] = 64;
	obj[DELAY#interp_offset] = obj[DELAY#interp_samples]/2;
	interp_buffer = obj[DELAY#interp_buffer] = freemem;
	freemem = interp_buffer + obj[DELAY#interp_samples]*obj[DELAY#interp_scale];
	i = 0;
	while (i < obj[DELAY#interp_samples]*obj[DELAY#interp_scale]) (
		wr = (i + 0.5)/(obj[DELAY#interp_samples]*obj[DELAY#interp_scale]);
		// Blackman window
		w = 0.42 - 0.5*cos(wr*$pi*2) + 0.08*cos(wr*$pi*4);
		t = i/obj[DELAY#interp_scale] - obj[DELAY#interp_offset];
		interp_buffer[i] = sinc(t*$pi)*w; // Windowed sinc
		i += 1;
	);
	freemem;
);

function delay_buffer_init(freemem, max_delay_samples) (
	delay_buffer_setup(freemem, max_delay_samples);
);

function delay_buffer_input(obj, spl) local(buffer, index) (
	index = (obj[DELAY#index] += 1);
	obj[DELAY#index] >= obj[DELAY#length] ? (
		index = obj[DELAY#index] = 0;
	);
	buffer = obj[DELAY#buffer];
	buffer[index] = spl;
	spl;
);

function delay_buffer_output_samples(obj, samples) local(index, buffer) (
	index = obj[DELAY#index] - samples;
	while (index < 0) (
		index += obj[DELAY#length];
	);
	buffer = obj[DELAY#buffer];
	buffer[index];
);

function delay_buffer_output_linear(obj, samples) local(index, index1, index2, ratio, i, interp_buffer, buffer, interp_index, sum) (
	index = obj[DELAY#index] - max(obj[DELAY#interp_samples], samples + obj[DELAY#interp_offset] - 1);
	index1 = floor(index);
	ratio = index - index1;
	while (index1 < 0) (
		index1 += obj[DELAY#length];
	);

	sum = 0;
	index = index1;
	buffer = obj[DELAY#buffer];
	interp_buffer = obj[DELAY#interp_buffer];
	interp_index = floor((1 - ratio)*obj[DELAY#interp_scale]);
	i = 0;
	while (i < obj[DELAY#interp_samples]) (
		sum += interp_buffer[interp_index]*buffer[index];
		interp_index += obj[DELAY#interp_scale];
		index += 1;
		index >= obj[DELAY#length] ? (
			index = 0;
		);
		i += 1;
	);
	sum;
);

// SHOULD NOT USE
function __deprecated__delay_buffer_output_allpass(obj, samples)
		local(buffer, interp_buffer, index, index1, index2, delta, ratio, x0, y0, a1, a2, b0, b1, b2) (
	buffer = obj[DELAY#buffer];
	index = obj[DELAY#index] - max(3, samples);
	index1 = ceil(index + 2 + 0.1); // This makes sure Delta is above 2
	Delta = index1 - index;
	Delta = 3;
	while (index1 < 0) (
		index1 += obj[DELAY#length];
	);

	obj[DELAY#allpass_prev_delay] != index1 ? (
		// Reset the filter
		index2 = index1 - 1;
		index2 < 0 ? index2 += obj[DELAY#length];
		obj[DELAY#allpass_x1] = buffer[index2];
		ratio = max(0, min(1, Delta));
		// Linear interpolation to simulate previous output
		obj[DELAY#allpass_y1] = buffer[index1] + ratio*(buffer[index2] - buffer[index1]);
		obj[DELAY#allpass_prev_delay] = index1;
	);

	// Second-order Thiran
	a1 = -2*(Delta - 2)/(Delta + 1);
	a2 = (Delta - 2)*(Delta - 1)/(Delta + 1)/(Delta + 2);
	b0 = a2;
	b1 = a1;
	b2 = 1;

	x0 = buffer[index1];
	y0 = b0*x0 + b1*obj[DELAY#allpass_x1] + b2*obj[DELAY#allpass_x2]
		- a1*obj[DELAY#allpass_y1] - a2*obj[DELAY#allpass_y2];
	obj[DELAY#allpass_x2] = obj[DELAY#allpass_x1];
	obj[DELAY#allpass_x1] = x0;
	obj[DELAY#allpass_y2] = obj[DELAY#allpass_y1];
	obj[DELAY#allpass_y1] = y0;
	y0;
);