function dB_to_linear(db){return Math.pow(10,db/20);}
class Fifo{ //FIFO (first in, first out) for samples.
	constructor(){this.buffer=[];}
	write(samples){this.buffer=this.buffer.concat(samples);}
	read(len){return this.buffer.splice(0,len);}
	peek(len){return this.buffer.slice(0,len);}
	push(sample){this.buffer.push(sample);}
}
class Filter{
	constructor(size){
		this.size=size;
		this.buffer=new Array(size).fill(0);
		this.ptr=0;
		this.store=0;
	}
	advance(){this.ptr=(this.ptr+1)%this.size;}
	//Simple comb filter process.
	combProcess(input,feedback,hfDamping){
		const output=this.buffer[this.ptr];
		this.store=output+(this.store-output)*hfDamping;
		this.buffer[this.ptr]=input+this.store*feedback;
		this.advance();
		return output;
	}
	//Simple allpass filter process.
	allpassProcess(input){
		const output=this.buffer[this.ptr];
		this.buffer[this.ptr]=input+output*0.5;
		this.advance();
		return output-input;
	}
}
class FilterArray{ //FilterArray with one set of comb and allpass filters.
	constructor(sampleRate,scale){
		//Set the delays relative to a reference sampleRate of 44100Hz.
		let combDelay=Math.round(scale*sampleRate/44100*1200);
		let allpassDelay=Math.round(sampleRate/44100*400);
		this.comb=new Filter(combDelay);
		this.allpass=new Filter(allpassDelay);
	}
	process(input,feedback,hfDamping,gain){
		//Process through comb filter.
		let outVal=this.comb.combProcess(input,feedback,hfDamping);
		//Process through allpass filter.
		outVal=this.allpass.allpassProcess(outVal);
		return outVal*gain;
	}
}
class Reverb{ //Reverb (a single-channel version)
	constructor(sampleRate,wetGain_dB,roomScale,reverberance,hfDamping,preDelay_ms){
		//Pre-delay is implemented as a FIFO delay.
		this.delaySamples=Math.round((preDelay_ms/1000)*sampleRate);
		this.fifo=new Fifo();
		//Preload delay with zeros.
		this.fifo.write(new Array(this.delaySamples).fill(0));

		//Scale and gain settings.
		this.scale=roomScale/100*0.9+0.1;
		//Simplified feedback calculation.
		this.feedback=1-Math.exp((reverberance-50)/50);
		this.hfDamping=hfDamping/100*0.3+0.2;
		this.gain=dB_to_linear(wetGain_dB)*0.015;
		
		//Create a filter array.
		this.filterArray=new FilterArray(sampleRate,this.scale);
	}
	//Process one sample.
	processSample(inputSample){
		//Push the incoming sample into the FIFO.
		this.fifo.push(inputSample);
		//Read one sample from the FIFO to get the pre-delayed sample.
		let delayed=this.fifo.read(1)[0]||0;
		//Process the delayed sample through our filter array.
		let wet=this.filterArray.process(delayed,this.feedback,this.hfDamping,this.gain);
		return wet;
	}
	//Process a block of samples.
	processBlock(inputSamples){
		let outputSamples=[];
		for(let i=0;i<inputSamples.length;i++){
			outputSamples.push(this.processSample(inputSamples[i]));
		}
		return outputSamples;
	}
}
class ReverbEffect{ //ReverbEffect wrapper that uses the Reverb unit.
	constructor(options){
		//Only mono channel is supported in this simplified example.
		this.sampleRate=options.sampleRate||44100;
		this.reverberance=options.reverberance!==undefined?options.reverberance:50;
		this.hfDamping=options.hfDamping!==undefined?options.hfDamping:50;
		this.roomScale=options.roomScale!==undefined?options.roomScale:100;
		this.preDelay_ms=options.preDelay_ms!==undefined?options.preDelay_ms:0;
		this.wetGain_dB=options.wetGain_dB!==undefined?options.wetGain_dB:0;
		this.wetOnly=!!options.wetOnly;
		
		this.reverb=new Reverb(
			this.sampleRate,
			this.wetGain_dB,
			this.roomScale,
			this.reverberance,
			this.hfDamping,
			this.preDelay_ms
		);
	}
	//Process a single sample in real time.
	processSample(inputSample){
		let wet=this.reverb.processSample(inputSample),dry=this.wetOnly?0:inputSample;
		return dry+wet;
	}
	//Process a block of samples.
	processBlock(inputSamples){
		let outputSamples=new Array(inputSamples.length);
		for(let i=0;i<inputSamples.length;i++){
			outputSamples[i]=this.processSample(inputSamples[i]);
		}
		return outputSamples;
	}
}

let sR=16000;
function kickGenerator(){
	let options={
	    	reverberance:72,
	    	hfDamping:220,
	    	roomScale:210,
	    	preDelay_ms:5, //a short pre-delay
	    	wetGain_dB:0,
	    	wetOnly:true,
	    	sampleRate:sR,
	    },
	    blockSize=128, //e.g., processing block size of 128 samples
	    inputSignal=new Array(9000).fill(0);
	for(let i=0;i<inputSignal.length;i++){
		//inputSignal[i]=Math.sin((i/sR)*Math.PI*2*5880);
		let t=i/sR;
		inputSignal[i]=Math.sin(13/(t+0.01)**2.6);
	}
	//Process the signal block by block.
	let processedSignal=inputSignal.slice(),m=40+Math.random()*10;
	for(let i=0;i<9;i++){
		options.roomScale=10+Math.floor(Math.random()*50);
		let temp=[],reverbEffect=new ReverbEffect(options); //Create the reverb effect instance (mono).
		for(let pos=0;pos<processedSignal.length;pos+=blockSize){
			let block=processedSignal.slice(pos,pos+blockSize),
			    processed=reverbEffect.processBlock(block);
			temp=temp.concat(processed);
		}
		processedSignal=temp.map(x=>x*m);
	}
	return processedSignal;
}
let kicks=[];
for(let i=0;i<24;i++)
	kicks.push(kickGenerator());
console.log(kicks);
function readArray(a,t){return t>=0&&t*sR<a.length?a[Math.floor(t*sR)]:0;}
let timer={current:0,stop:sR*.1},
    voices=[];
return function dsp(time){
	timer.current++;
	if(timer.current>=timer.stop){
		timer.current=timer.current%timer.stop;
		voices.push({
			kickIndex:Math.floor(Math.random()*kicks.length),
			time:0,
			speed:.2+(Math.random()**2)*6,
			reverse:Math.random()>.5,channel:+(Math.random()>.5)
		});
	}
	let master=[0,0];
	for(let i=0;i<voices.length;i++){
		let voice=voices[i];
		master[voice.channel]+=readArray(kicks[voice.kickIndex],voice.reverse?(kicks[voice.kickIndex].length/sR)-(voice.time*voice.speed):voice.time*voice.speed);
		master[1-voice.channel]+=(readArray(kicks[voice.kickIndex],voice.reverse?(kicks[voice.kickIndex].length/sR)-(voice.time*voice.speed):voice.time*voice.speed*1.01))*.5;
		voice.time+=1/sR;
		if(voice.time*voice.speed*sR>=kicks[voice.kickIndex].length){
			voices.splice(i,1);
			i--;
		}
	}
	return[Math.tanh(master[0]),Math.tanh(master[1])];
}