/*************************************************************************/
/*  reverb.cpp                                                           */
/*************************************************************************/
/*                       This file is part of:                           */
/*                           GODOT ENGINE                                */
/*                    http://www.godotengine.org                         */
/*************************************************************************/
/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur.                 */
/*                                                                       */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the       */
/* "Software"), to deal in the Software without restriction, including   */
/* without limitation the rights to use, copy, modify, merge, publish,   */
/* distribute, sublicense, and/or sell copies of the Software, and to    */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions:                                             */
/*                                                                       */
/* The above copyright notice and this permission notice shall be        */
/* included in all copies or substantial portions of the Software.       */
/*                                                                       */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
/*************************************************************************/

// Author: Juan Linietsky <reduzio@gmail.com>, (C) 2006

#include "reverb.h"
#include <math.h>
#include "math_funcs.h"


const float Reverb::comb_tunings[MAX_COMBS]={
	//freeverb comb tunings
	0.025306122448979593,
	0.026938775510204082,
	0.028956916099773241,
	0.03074829931972789,
	0.032244897959183672,
	0.03380952380952381,
	0.035306122448979592,
	0.036666666666666667
};

const float Reverb::allpass_tunings[MAX_ALLPASS]={
	//freeverb allpass tunings
	0.0051020408163265302,
	0.007732426303854875,
	0.01,
	0.012607709750566893
};



void Reverb::process(float *p_src,float *p_dst,int p_frames) {

	if (p_frames>INPUT_BUFFER_MAX_SIZE)
		p_frames=INPUT_BUFFER_MAX_SIZE;

	int predelay_frames=lrint((params.predelay/1000.0)*params.mix_rate);
	if (predelay_frames<10)
		predelay_frames=10;
	if (predelay_frames>=echo_buffer_size)
		predelay_frames=echo_buffer_size-1;

	for (int i=0;i<p_frames;i++) {

		if (echo_buffer_pos>=echo_buffer_size)
			echo_buffer_pos=0;

		int read_pos=echo_buffer_pos-predelay_frames;
		while (read_pos<0)
			read_pos+=echo_buffer_size;

		float in=undenormalise(echo_buffer[read_pos]*params.predelay_fb+p_src[i]);

		echo_buffer[echo_buffer_pos]=in;

		input_buffer[i]=in;

		p_dst[i]=0; //take the chance and clear this

		echo_buffer_pos++;
	}

	if (params.hpf>0) {
		float hpaux=expf(-2.0*Math_PI*params.hpf*6000/params.mix_rate);
		float hp_a1=(1.0+hpaux)/2.0;
		float hp_a2=-(1.0+hpaux)/2.0;
		float hp_b1=hpaux;

		for (int i=0;i<p_frames;i++) {

			float in=input_buffer[i];
			input_buffer[i]=in*hp_a1+hpf_h1*hp_a2+hpf_h2*hp_b1;
			hpf_h2=input_buffer[i];
			hpf_h1=in;
		}
	}

	for (int i=0;i<MAX_COMBS;i++) {

		Comb &c=comb[i];

		int size_limit=c.size-lrintf((float)c.extra_spread_frames*(1.0-params.extra_spread));
		for (int j=0;j<p_frames;j++) {

			if (c.pos>=size_limit) //reset this now just in case
				c.pos=0;

			float out=undenormalise(c.buffer[c.pos]*c.feedback);
			out=out*(1.0-c.damp)+c.damp_h*c.damp; //lowpass
			c.damp_h=out;
			c.buffer[c.pos]=input_buffer[j]+out;
			p_dst[j]+=out;
			c.pos++;
		}

	}


	static const float allpass_feedback=0.7;
	/* this one works, but the other version is just nicer....
	int ap_size_limit[MAX_ALLPASS];

	for (int i=0;i<MAX_ALLPASS;i++) {

		AllPass &a=allpass[i];
		ap_size_limit[i]=a.size-lrintf((float)a.extra_spread_frames*(1.0-params.extra_spread));
	}

	for (int i=0;i<p_frames;i++) {

		float sample=p_dst[i];
		float aux,in;
		float AllPass*ap;

#define PROCESS_ALLPASS(m_ap) 	\
	ap=&allpass[m_ap];	\
	if (ap->pos>=ap_size_limit[m_ap])	\
		ap->pos=0;	\
	aux=undenormalise(ap->buffer[ap->pos]);	\
	in=sample;	\
	sample=-in+aux;	\
	ap->pos++;


		PROCESS_ALLPASS(0);
		PROCESS_ALLPASS(1);
		PROCESS_ALLPASS(2);
		PROCESS_ALLPASS(3);

		p_dst[i]=sample;
	}
	*/

	for (int i=0;i<MAX_ALLPASS;i++) {

		AllPass &a=allpass[i];
		int size_limit=a.size-lrintf((float)a.extra_spread_frames*(1.0-params.extra_spread));

		for (int j=0;j<p_frames;j++) {

			if (a.pos>=size_limit)
				a.pos=0;

			float aux=a.buffer[a.pos];
			a.buffer[a.pos]=undenormalise(allpass_feedback*aux+p_dst[j]);
			p_dst[j]=aux-allpass_feedback*a.buffer[a.pos];
			a.pos++;

		}
	}

	static const float wet_scale=0.6;

	for (int i=0;i<p_frames;i++) {


		p_dst[i]=p_dst[i]*params.wet*wet_scale+p_src[i]*params.dry;
	}

}


void Reverb::set_room_size(float p_size) {

	params.room_size=p_size;
	update_parameters();

}
void Reverb::set_damp(float p_damp) {

	params.damp=p_damp;
	update_parameters();

}
void Reverb::set_wet(float p_wet) {

	params.wet=p_wet;

}

void Reverb::set_dry(float p_dry) {

	params.dry=p_dry;

}

void Reverb::set_predelay(float p_predelay) {

	params.predelay=p_predelay;
}
void Reverb::set_predelay_feedback(float p_predelay_fb) {

	params.predelay_fb=p_predelay_fb;

}

void Reverb::set_highpass(float p_frq) {

	if (p_frq>1)
		p_frq=1;
	if (p_frq<0)
		p_frq=0;
	params.hpf=p_frq;
}

void Reverb::set_extra_spread(float p_spread) {

	params.extra_spread=p_spread;

}


void Reverb::set_mix_rate(float p_mix_rate) {

	params.mix_rate=p_mix_rate;
	configure_buffers();
}

void Reverb::set_extra_spread_base(float p_sec) {

	params.extra_spread_base=p_sec;
	configure_buffers();
}


void Reverb::configure_buffers() {

	clear_buffers(); //clear if necesary

	for (int i=0;i<MAX_COMBS;i++) {

		Comb &c=comb[i];


		c.extra_spread_frames=lrint(params.extra_spread_base*params.mix_rate);

		int len=lrint(comb_tunings[i]*params.mix_rate)+c.extra_spread_frames;
		if (len<5)
			len=5; //may this happen?

		c.buffer = memnew_arr(float,len);
		c.pos=0;
		for (int j=0;j<len;j++)
			c.buffer[j]=0;
		c.size=len;

	}

	for (int i=0;i<MAX_ALLPASS;i++) {

		AllPass &a=allpass[i];

		a.extra_spread_frames=lrint(params.extra_spread_base*params.mix_rate);

		int len=lrint(allpass_tunings[i]*params.mix_rate)+a.extra_spread_frames;
		if (len<5)
			len=5; //may this happen?

		a.buffer = memnew_arr(float,len);
		a.pos=0;
		for (int j=0;j<len;j++)
			a.buffer[j]=0;
		a.size=len;
	}

	echo_buffer_size=(int)(((float)MAX_ECHO_MS/1000.0)*params.mix_rate+1.0);
	echo_buffer = memnew_arr(float,echo_buffer_size);
	for (int i=0;i<echo_buffer_size;i++) {

		echo_buffer[i]=0;
	}

	echo_buffer_pos=0;
}


void Reverb::update_parameters() {

	//more freeverb derived constants
	static const float room_scale = 0.28f;
	static const float room_offset = 0.7f;

	for (int i=0;i<MAX_COMBS;i++) {

		Comb &c=comb[i];
		c.feedback=room_offset+params.room_size*room_scale;
		if (c.feedback<room_offset)
			c.feedback=room_offset;
		else if (c.feedback>(room_offset+room_scale))
			c.feedback=(room_offset+room_scale);

		float auxdmp=params.damp/2.0+0.5; //only half the range (0.5 .. 1.0  is enough)
		auxdmp*=auxdmp;

		c.damp=expf(-2.0*Math_PI*auxdmp*10000/params.mix_rate); // 0 .. 10khz
	}

}

void Reverb::clear_buffers() {

	if (echo_buffer)
		memdelete_arr(echo_buffer);

	for (int i=0;i<MAX_COMBS;i++) {

		if (comb[i].buffer)
			memdelete_arr(comb[i].buffer);

		comb[i].buffer=0;

	}

	for (int i=0;i<MAX_ALLPASS;i++) {

		if (allpass[i].buffer)
			memdelete_arr(allpass[i].buffer);

		allpass[i].buffer=0;
	}

}

Reverb::Reverb() {

	params.room_size=0.8;
	params.damp=0.5;
	params.dry=1.0;
	params.wet=0.0;
	params.mix_rate=44100;
	params.extra_spread_base=0;
	params.extra_spread=1.0;
	params.predelay=150;
	params.predelay_fb=0.4;
	params.hpf=0;
	hpf_h1=0;
	hpf_h2=0;


	input_buffer=memnew_arr(float,INPUT_BUFFER_MAX_SIZE);
	echo_buffer=0;

	configure_buffers();
	update_parameters();


}


Reverb::~Reverb() {

	memdelete_arr(input_buffer);
	clear_buffers();
}